Merge branch 'next' into feature/authentik-provider

.dockerignore

@@ -3,7 +3,6 @@
 /public/build
 /public/hot
 /public/storage
-/storage/*.key
 /vendor
 .env
 .env.backup
@@ -23,3 +22,17 @@ yarn-error.log
 .rnd
 /.ssh
 .ignition.json
+.env.dusk.local
+docker/coolify-realtime/node_modules
+
+/storage/*.key
+/storage/app/backups
+/storage/app/ssh/keys
+/storage/app/ssh/mux
+/storage/app/tmp
+/storage/app/debugbar
+/storage/logs
+/storage/pail
+
+
+

.env.dusk.ci

@@ -0,0 +1,15 @@
+APP_ENV=production
+APP_NAME="Coolify Staging"
+APP_ID=development
+APP_KEY=
+APP_URL=http://localhost
+APP_PORT=8000
+SSH_MUX_ENABLED=true
+
+# PostgreSQL Database Configuration
+DB_DATABASE=coolify
+DB_USERNAME=coolify
+DB_PASSWORD=password
+DB_HOST=localhost
+DB_PORT=5432
+

.env.windows-docker-desktop.example

@@ -4,6 +4,7 @@ APP_ID=coolify-windows-docker-desktop
 APP_NAME=Coolify
 APP_KEY=base64:ssTlCmrIE/q7whnKMvT6DwURikg69COzGsAwFVROm80=
 
+DB_USERNAME=coolify
 DB_PASSWORD=coolify
 REDIS_PASSWORD=coolify
 

.gitattributes

@@ -8,4 +8,4 @@
 
 /.github export-ignore
 CHANGELOG.md export-ignore
-.styleci.yml export-ignore
+.styleci.yml export-ignore

.github/workflows/browser-tests.yml

@@ -0,0 +1,65 @@
+name: Dusk
+on:
+  push:
+    branches: [ "not-existing" ]
+jobs:
+  dusk:
+    runs-on: ubuntu-latest
+
+    services:
+      redis:
+        image: redis
+        env:
+          REDIS_HOST: localhost
+          REDIS_PORT: 6379
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up PostgreSQL
+        run: |
+          sudo systemctl start postgresql
+          sudo -u postgres psql -c "CREATE DATABASE coolify;"
+          sudo -u postgres psql -c "CREATE USER coolify WITH PASSWORD 'password';"
+          sudo -u postgres psql -c "ALTER ROLE coolify SET client_encoding TO 'utf8';"
+          sudo -u postgres psql -c "ALTER ROLE coolify SET default_transaction_isolation TO 'read committed';"
+          sudo -u postgres psql -c "ALTER ROLE coolify SET timezone TO 'UTC';"
+          sudo -u postgres psql -c "GRANT ALL PRIVILEGES ON DATABASE coolify TO coolify;"
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: '8.2'
+      - name: Copy .env
+        run: cp .env.dusk.ci .env
+      - name: Install Dependencies
+        run: composer install --no-progress --prefer-dist --optimize-autoloader
+      - name: Generate key
+        run: php artisan key:generate
+      - name: Install Chrome binaries
+        run: php artisan dusk:chrome-driver --detect
+      - name: Start Chrome Driver
+        run: ./vendor/laravel/dusk/bin/chromedriver-linux --port=4444 &
+      - name: Build assets
+        run: npm install && npm run build
+      - name: Run Laravel Server
+        run: php artisan serve --no-reload &
+      - name: Execute tests
+        run: php artisan dusk
+      - name: Upload Screenshots
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: screenshots
+          path: tests/Browser/screenshots
+      - name: Upload Console Logs
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: console
+          path: tests/Browser/console

.github/workflows/coolify-helper-next.yml

@@ -1,4 +1,4 @@
-name: Coolify Helper Image Development (v4)
+name: Coolify Helper Image Development
 
 on:
   push:
@@ -8,7 +8,8 @@ on:
       - docker/coolify-helper/Dockerfile
 
 env:
-  REGISTRY: ghcr.io
+  GITHUB_REGISTRY: ghcr.io
+  DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify-helper"
 
 jobs:
@@ -19,25 +20,36 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@v4
-      - name: Login to ghcr.io
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.helper.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
         with:
-          no-cache: true
           context: .
           file: docker/coolify-helper/Dockerfile
           platforms: linux/amd64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
           labels: |
             coolify.managed=true
   aarch64:
@@ -47,27 +59,39 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@v4
-      - name: Login to ghcr.io
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.helper.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
         with:
-          no-cache: true
           context: .
           file: docker/coolify-helper/Dockerfile
           platforms: linux/aarch64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
           labels: |
             coolify.managed=true
+
   merge-manifest:
     runs-on: ubuntu-latest
     permissions:
@@ -75,25 +99,42 @@ jobs:
       packages: write
     needs: [ amd64, aarch64 ]
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to ghcr.io
+      - uses: actions/checkout@v4
+      - uses: docker/setup-buildx-action@v3
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
            echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.helper.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Create & publish manifest
+
+      - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
-          docker buildx imagetools create --append ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:next
+          docker buildx imagetools create \
+          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:next
+
+      - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
+        run: |
+          docker buildx imagetools create \
+          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:next
+
       - uses: sarisia/actions-status-discord@v1
         if: always()
         with:

.github/workflows/coolify-helper.yml

@@ -1,4 +1,4 @@
-name: Coolify Helper Image (v4)
+name: Coolify Helper Image
 
 on:
   push:
@@ -8,7 +8,8 @@ on:
       - docker/coolify-helper/Dockerfile
 
 env:
-  REGISTRY: ghcr.io
+  GITHUB_REGISTRY: ghcr.io
+  DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify-helper"
 
 jobs:
@@ -19,25 +20,36 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@v4
-      - name: Login to ghcr.io
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.helper.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
         with:
-          no-cache: true
           context: .
           file: docker/coolify-helper/Dockerfile
           platforms: linux/amd64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
           labels: |
             coolify.managed=true
   aarch64:
@@ -47,25 +59,36 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@v4
-      - name: Login to ghcr.io
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
-           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.helper.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
+          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.helper.version' versions.json)"|xargs >> $GITHUB_OUTPUT
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
         with:
-          no-cache: true
           context: .
           file: docker/coolify-helper/Dockerfile
           platforms: linux/aarch64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
           labels: |
             coolify.managed=true
   merge-manifest:
@@ -75,25 +98,43 @@ jobs:
       packages: write
     needs: [ amd64, aarch64 ]
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to ghcr.io
+      - uses: actions/checkout@v4
+
+      - uses: docker/setup-buildx-action@v3
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
-           echo "VERSION=$(docker run  --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.helper.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Create & publish manifest
+           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.helper.version' versions.json)"|xargs >> $GITHUB_OUTPUT
+
+      - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
-          docker buildx imagetools create --append ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+          docker buildx imagetools create \
+          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+
+      - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
+        run: |
+          docker buildx imagetools create \
+          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+
       - uses: sarisia/actions-status-discord@v1
         if: always()
         with:

.github/workflows/coolify-production-build.yml

@@ -0,0 +1,139 @@
+name: Production Build (v4)
+
+on:
+  push:
+    branches: ["main"]
+    paths-ignore:
+      - .github/workflows/coolify-helper.yml
+      - .github/workflows/coolify-helper-next.yml
+      - .github/workflows/coolify-realtime.yml
+      - .github/workflows/coolify-realtime-next.yml
+      - docker/coolify-helper/Dockerfile
+      - docker/coolify-realtime/Dockerfile
+      - docker/testing-host/Dockerfile
+      - templates/**
+
+env:
+  GITHUB_REGISTRY: ghcr.io
+  DOCKER_REGISTRY: docker.io
+  IMAGE_NAME: "coollabsio/coolify"
+
+jobs:
+  amd64:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.GITHUB_REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Get Version
+        id: version
+        run: |
+          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getVersion.php)"|xargs >> $GITHUB_OUTPUT
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/production/Dockerfile
+          platforms: linux/amd64
+          push: true
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
+
+  aarch64:
+    runs-on: [self-hosted, arm64]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.GITHUB_REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Get Version
+        id: version
+        run: |
+          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getVersion.php)"|xargs >> $GITHUB_OUTPUT
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/production/Dockerfile
+          platforms: linux/aarch64
+          push: true
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
+
+  merge-manifest:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    needs: [amd64, aarch64]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: docker/setup-buildx-action@v3
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.GITHUB_REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Get Version
+        id: version
+        run: |
+          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getVersion.php)"|xargs >> $GITHUB_OUTPUT
+
+      - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
+        run: |
+          docker buildx imagetools create \
+          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+
+      - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
+        run: |
+          docker buildx imagetools create \
+          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+
+      - uses: sarisia/actions-status-discord@v1
+        if: always()
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK_PROD_RELEASE_CHANNEL  }}

.github/workflows/coolify-realtime-next.yml

@@ -1,17 +1,19 @@
-name: Coolify Realtime Development (v4)
+name: Coolify Realtime Development
 
 on:
   push:
     branches: [ "next" ]
     paths:
-      - .github/workflows/coolify-realtime.yml
+      - .github/workflows/coolify-realtime-next.yml
       - docker/coolify-realtime/Dockerfile
       - docker/coolify-realtime/terminal-server.js
       - docker/coolify-realtime/package.json
+      - docker/coolify-realtime/package-lock.json
       - docker/coolify-realtime/soketi-entrypoint.sh
 
 env:
-  REGISTRY: ghcr.io
+  GITHUB_REGISTRY: ghcr.io
+  DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify-realtime"
 
 jobs:
@@ -22,27 +24,39 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@v4
-      - name: Login to ghcr.io
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.realtime.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
         with:
-          no-cache: true
           context: .
           file: docker/coolify-realtime/Dockerfile
           platforms: linux/amd64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
           labels: |
             coolify.managed=true
+
   aarch64:
     runs-on: [ self-hosted, arm64 ]
     permissions:
@@ -50,27 +64,39 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@v4
-      - name: Login to ghcr.io
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
            echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.realtime.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
         with:
-          no-cache: true
           context: .
           file: docker/coolify-realtime/Dockerfile
           platforms: linux/aarch64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
           labels: |
             coolify.managed=true
+
   merge-manifest:
     runs-on: ubuntu-latest
     permissions:
@@ -78,26 +104,44 @@ jobs:
       packages: write
     needs: [ amd64, aarch64 ]
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to ghcr.io
+      - uses: actions/checkout@v4
+
+      - uses: docker/setup-buildx-action@v3
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
            echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.realtime.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Create & publish manifest
+
+      - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
-          docker buildx imagetools create --append ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
+          docker buildx imagetools create \
+          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:next
+
+      - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
+        run: |
+          docker buildx imagetools create \
+          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:next
+
       - uses: sarisia/actions-status-discord@v1
         if: always()
         with:
-          webhook: ${{ secrets.DISCORD_WEBHOOK_PROD_RELEASE_CHANNEL  }}
+          webhook: ${{ secrets.DISCORD_WEBHOOK_DEV_RELEASE_CHANNEL  }}

.github/workflows/coolify-realtime.yml

@@ -1,4 +1,4 @@
-name: Coolify Realtime (v4)
+name: Coolify Realtime
 
 on:
   push:
@@ -8,10 +8,12 @@ on:
       - docker/coolify-realtime/Dockerfile
       - docker/coolify-realtime/terminal-server.js
       - docker/coolify-realtime/package.json
+      - docker/coolify-realtime/package-lock.json
       - docker/coolify-realtime/soketi-entrypoint.sh
 
 env:
-  REGISTRY: ghcr.io
+  GITHUB_REGISTRY: ghcr.io
+  DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify-realtime"
 
 jobs:
@@ -22,27 +24,39 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@v4
-      - name: Login to ghcr.io
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.realtime.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
         with:
-          no-cache: true
           context: .
           file: docker/coolify-realtime/Dockerfile
           platforms: linux/amd64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
           labels: |
             coolify.managed=true
+
   aarch64:
     runs-on: [ self-hosted, arm64 ]
     permissions:
@@ -50,27 +64,39 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@v4
-      - name: Login to ghcr.io
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
            echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.realtime.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
         with:
-          no-cache: true
           context: .
           file: docker/coolify-realtime/Dockerfile
           platforms: linux/aarch64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
           labels: |
             coolify.managed=true
+
   merge-manifest:
     runs-on: ubuntu-latest
     permissions:
@@ -78,25 +104,43 @@ jobs:
       packages: write
     needs: [ amd64, aarch64 ]
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to ghcr.io
+      - uses: actions/checkout@v4
+
+      - uses: docker/setup-buildx-action@v3
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
       - name: Get Version
         id: version
         run: |
            echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app ghcr.io/jqlang/jq:latest '.coolify.realtime.version' versions.json)"|xargs >> $GITHUB_OUTPUT
-      - name: Create & publish manifest
+
+      - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
-          docker buildx imagetools create --append ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+          docker buildx imagetools create \
+          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+
+      - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
+        run: |
+          docker buildx imagetools create \
+          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+
       - uses: sarisia/actions-status-discord@v1
         if: always()
         with:

.github/workflows/coolify-staging-build.yml

@@ -0,0 +1,125 @@
+name: Staging Build
+
+on:
+  push:
+    branches-ignore: ["main", "v3"]
+    paths-ignore:
+        - .github/workflows/coolify-helper.yml
+        - .github/workflows/coolify-helper-next.yml
+        - .github/workflows/coolify-realtime.yml
+        - .github/workflows/coolify-realtime-next.yml
+        - docker/coolify-helper/Dockerfile
+        - docker/coolify-realtime/Dockerfile
+        - docker/testing-host/Dockerfile
+        - templates/**
+
+env:
+  GITHUB_REGISTRY: ghcr.io
+  DOCKER_REGISTRY: docker.io
+  IMAGE_NAME: "coollabsio/coolify"
+
+jobs:
+  amd64:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.GITHUB_REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/production/Dockerfile
+          platforms: linux/amd64
+          push: true
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
+
+  aarch64:
+    runs-on: [self-hosted, arm64]
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.GITHUB_REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/production/Dockerfile
+          platforms: linux/aarch64
+          push: true
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64
+
+  merge-manifest:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    needs: [amd64, aarch64]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: docker/setup-buildx-action@v3
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.GITHUB_REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
+        run: |
+         docker buildx imagetools create \
+         --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64 \
+         --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
+
+      - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
+        run: |
+          docker buildx imagetools create \
+          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64 \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
+
+      - uses: sarisia/actions-status-discord@v1
+        if: always()
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK_DEV_RELEASE_CHANNEL  }}

.github/workflows/coolify-testing-host.yml

@@ -1,14 +1,15 @@
-name: Coolify Testing Host (v4-non-prod)
+name: Coolify Testing Host
 
 on:
   push:
-    branches: [ "main", "next" ]
+    branches: [ "next" ]
     paths:
       - .github/workflows/coolify-testing-host.yml
       - docker/testing-host/Dockerfile
 
 env:
-  REGISTRY: ghcr.io
+  GITHUB_REGISTRY: ghcr.io
+  DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify-testing-host"
 
 jobs:
@@ -19,21 +20,34 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@v4
-      - name: Login to ghcr.io
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
         with:
-          no-cache: true
           context: .
           file: docker/testing-host/Dockerfile
           platforms: linux/amd64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+          labels: |
+            coolify.managed=true
+
   aarch64:
     runs-on: [ self-hosted, arm64 ]
     permissions:
@@ -41,21 +55,34 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@v4
-      - name: Login to ghcr.io
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Build and Push Image
+        uses: docker/build-push-action@v6
         with:
-          no-cache: true
           context: .
           file: docker/testing-host/Dockerfile
           platforms: linux/aarch64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64
+          tags: |
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64
+          labels: |
+            coolify.managed=true
+
   merge-manifest:
     runs-on: ubuntu-latest
     permissions:
@@ -63,21 +90,36 @@ jobs:
       packages: write
     needs: [ amd64, aarch64 ]
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to ghcr.io
+      - uses: actions/checkout@v4
+
+      - uses: docker/setup-buildx-action@v3
+
+      - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITHUB_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN  }}
-      - name: Create & publish manifest
+
+      - name: Login to ${{ env.DOCKER_REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
-          docker buildx imagetools create --append ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64 --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+          docker buildx imagetools create \
+          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64 \
+          --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+
+      - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
+        run: |
+          docker buildx imagetools create \
+          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64 \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+
       - uses: sarisia/actions-status-discord@v1
         if: always()
         with:

.github/workflows/development-build.yml

@@ -1,79 +0,0 @@
-name: Development Build (v4)
-
-on:
-  push:
-    branches-ignore: ["main", "v3"]
-    paths-ignore:
-      - .github/workflows/coolify-helper.yml
-      - docker/coolify-helper/Dockerfile
-
-env:
-  REGISTRY: ghcr.io
-  IMAGE_NAME: "coollabsio/coolify"
-
-jobs:
-  amd64:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Login to ghcr.io
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: docker/prod/Dockerfile
-          platforms: linux/amd64
-          push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
-  aarch64:
-    runs-on: [self-hosted, arm64]
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-      - name: Login to ghcr.io
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: docker/prod/Dockerfile
-          platforms: linux/aarch64
-          push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64
-  merge-manifest:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    needs: [amd64, aarch64]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to ghcr.io
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-      - name: Create & publish manifest
-        run: |
-          docker buildx imagetools create --append ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64 --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
-      - uses: sarisia/actions-status-discord@v1
-        if: always()
-        with:
-          webhook: ${{ secrets.DISCORD_WEBHOOK_DEV_RELEASE_CHANNEL  }}

.github/workflows/production-build.yml

@@ -1,89 +0,0 @@
-name: Production Build (v4)
-
-on:
-  push:
-    branches: ["main"]
-    paths-ignore:
-      - .github/workflows/coolify-helper.yml
-      - docker/coolify-helper/Dockerfile
-      - templates/service-templates.json
-
-env:
-  REGISTRY: ghcr.io
-  IMAGE_NAME: "coollabsio/coolify"
-
-jobs:
-  amd64:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Login to ghcr.io
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-      - name: Get Version
-        id: version
-        run: |
-          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getVersion.php)"|xargs >> $GITHUB_OUTPUT
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: docker/prod/Dockerfile
-          platforms: linux/amd64
-          push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
-  aarch64:
-    runs-on: [self-hosted, arm64]
-    steps:
-      - uses: actions/checkout@v4
-      - name: Login to ghcr.io
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-      - name: Get Version
-        id: version
-        run: |
-          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getVersion.php)"|xargs >> $GITHUB_OUTPUT
-      - name: Build image and push to registry
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: docker/prod/Dockerfile
-          platforms: linux/aarch64
-          push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
-  merge-manifest:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    needs: [amd64, aarch64]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to ghcr.io
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-      - name: Get Version
-        id: version
-        run: |
-          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getVersion.php)"|xargs >> $GITHUB_OUTPUT
-      - name: Create & publish manifest
-        run: |
-          docker buildx imagetools create --append ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
-      - uses: sarisia/actions-status-discord@v1
-        if: always()
-        with:
-          webhook: ${{ secrets.DISCORD_WEBHOOK_PROD_RELEASE_CHANNEL  }}

.gitignore

@@ -33,3 +33,6 @@ _ide_helper_models.php
 /.ssh
 scripts/load-test/*
 .ignition.json
+.env.dusk.local
+docker/coolify-realtime/node_modules
+.DS_Store

.gitpod.yml

@@ -1,65 +0,0 @@
-tasks:
-  - name: Setup Spin environment and Composer dependencies
-    # Fix because of https://github.com/gitpod-io/gitpod/issues/16614
-    before: sudo curl -o /usr/local/bin/docker-compose -fsSL https://github.com/docker/compose/releases/download/v2.16.0/docker-compose-linux-$(uname -m)
-    init: |
-      cp .env.development.example .env &&
-      sed -i "s#APP_URL=http://localhost#APP_URL=$(gp url 8000)#g" .env
-      sed -i "s#USERID=#USERID=33333#g" .env
-      sed -i "s#GROUPID=#GROUPID=33333#g" .env
-      composer install --ignore-platform-reqs
-      ./vendor/bin/spin up -d
-      ./vendor/bin/spin exec -u webuser coolify php artisan key:generate
-      ./vendor/bin/spin exec -u webuser coolify php artisan storage:link
-      ./vendor/bin/spin exec -u webuser coolify php artisan migrate:fresh --seed
-      cat .coolify-logo
-      gp sync-done spin-is-ready
-
-  - name: Install Node dependencies and run Vite
-    command: |
-      echo "Waiting for Sail environment to boot up."
-      gp sync-await spin-is-ready
-      ./vendor/bin/spin exec vite npm install
-      ./vendor/bin/spin exec vite npm run dev -- --host
-
-  - name: Laravel Queue Worker, listening to code changes
-    command: |
-      echo "Waiting for Sail environment to boot up."
-      gp sync-await spin-is-ready
-      ./vendor/bin/spin exec -u webuser coolify php artisan queue:listen
-
-ports:
-  - port: 5432
-    onOpen: ignore
-    name: PostgreSQL
-    visibility: public
-  - port: 5173
-    onOpen: ignore
-    visibility: public
-    name: Node Server for Vite
-  - port: 8000
-    onOpen: ignore
-    visibility: public
-    name: Coolify
-
-# Configure vscode
-vscode:
-  extensions:
-    - bmewburn.vscode-intelephense-client
-    - ikappas.composer
-    - ms-azuretools.vscode-docker
-    - ecmel.vscode-html-css
-    - MehediDracula.php-namespace-resolver
-    - wmaurer.change-case
-    - Equinusocio.vsc-community-material-theme
-    - EditorConfig.EditorConfig
-    - streetsidesoftware.code-spell-checker
-    - rangav.vscode-thunder-client
-    - PKief.material-icon-theme
-    - cierra.livewire-vscode
-    - lennardv.livewire-goto-updated
-    - bradlc.vscode-tailwindcss
-    - heybourn.headwind
-    - adrianwilczynski.alpine-js-intellisense
-    - amiralizadeh9480.laravel-extra-intellisense
-    - shufo.vscode-blade-formatter

README.md

@@ -5,7 +5,7 @@
 
 # About the Project
 
-Coolify is an open-source & self-hostable alternative to Heroku / Netlify / Vercel / etc. 
+Coolify is an open-source & self-hostable alternative to Heroku / Netlify / Vercel / etc.
 
 It helps you manage your servers, applications, and databases on your own hardware; you only need an SSH connection. You can manage VPS, Bare Metal, Raspberry PIs, and anything else.
 
@@ -22,6 +22,9 @@ # Installation
 ```
 You can find the installation script source [here](./scripts/install.sh).
 
+> [!NOTE]
+> Please refer to the [docs](https://coolify.io/docs/installation) for more information about the installation.
+
 # Support
 
 Contact us at [coolify.io/docs/contact](https://coolify.io/docs/contact).
@@ -37,21 +40,21 @@ # Donations
 
 ### Special Sponsors
 
-![image](https://github.com/user-attachments/assets/c95a07df-7c5a-4e77-a35a-81f25fcbece1)
+![image](https://github.com/user-attachments/assets/726fb63e-c3b8-4260-b3ac-06780605ec5d)
 
 * [CCCareers](https://cccareers.org/) - A career development platform connecting coding bootcamp graduates with job opportunities in the tech industry.
 * [Hetzner](http://htznr.li/CoolifyXHetzner) - A German web hosting company offering affordable dedicated servers, cloud services, and web hosting solutions.
 * [Logto](https://logto.io/?ref=coolify) - An open-source authentication and authorization solution for building secure login systems and managing user identities.
+* [Tolgee](https://tolgee.io/?ref=coolify) - Developer & translator friendly web-based localization platform.
 * [BC Direct](https://bc.direct/?ref=coolify.io) - A digital marketing agency specializing in e-commerce solutions and online business growth strategies.
 * [QuantCDN](https://www.quantcdn.io/?ref=coolify.io) - A content delivery network (CDN) optimizing website performance through global content distribution.
 * [Arcjet](https://arcjet.com/?ref=coolify.io) - A cloud-based platform providing real-time protection against API abuse and bot attacks.
 * [SupaGuide](https://supa.guide/?ref=coolify.io) - A comprehensive resource hub offering guides and tutorials for web development using Supabase.
+* [GoldenVM](https://billing.goldenvm.com/?ref=coolify.io) - A cloud hosting provider offering scalable infrastructure solutions for businesses of all sizes.
 * [Tigris](https://tigrisdata.com/?ref=coolify.io) - A fully managed serverless object storage service compatible with Amazon S3 API. Offers high performance, scalability, and built-in search capabilities for efficient data management.
-* [Fractal Networks](https://fractalnetworks.co/?ref=coolify.io) - A decentralized network infrastructure company focusing on secure and private communication solutions.
 * [Advin](https://coolify.ad.vin/?ref=coolify.io) - A digital advertising agency specializing in programmatic advertising and data-driven marketing strategies.
 * [Treive](https://trieve.ai/?ref=coolify.io) - An AI-powered search and discovery platform for enhancing information retrieval in large datasets.
 * [Blacksmith](https://blacksmith.sh/?ref=coolify.io) - A cloud-native platform for automating infrastructure provisioning and management across multiple cloud providers.
-* [Latitude](https://latitude.sh/?ref=coolify.io) - A cloud computing platform offering bare metal servers and cloud instances for developers and businesses.
 * [Brand Dev](https://brand.dev/?ref=coolify.io) - A web development agency specializing in creating custom digital experiences and brand identities.
 * [Jobscollider](https://jobscollider.com/remote-jobs?ref=coolify.io) - A job search platform connecting professionals with remote work opportunities across various industries.
 * [Hostinger](https://www.hostinger.com/vps/coolify-hosting?ref=coolify.io) - A web hosting provider offering affordable hosting solutions, domain registration, and website building tools.
@@ -60,6 +63,7 @@ ### Special Sponsors
 * [Juxtdigital](https://juxtdigital.dev/?ref=coolify.io) - A digital agency offering web development, design, and digital marketing services for businesses.
 * [Saasykit](https://saasykit.com/?ref=coolify.io) - A Laravel-based boilerplate providing essential components and features for building SaaS applications quickly.
 * [Massivegrid](https://massivegrid.com/?ref=coolify.io) - A cloud hosting provider offering scalable infrastructure solutions for businesses of all sizes.
+* [LiquidWeb](https://liquidweb.com/?utm_source=coolify.io) - Fast web hosting provider.
 
 
 ## Github Sponsors ($40+)
@@ -87,7 +91,11 @@ ## Github Sponsors ($40+)
 <a href="https://github.com/urtho"><img src="https://github.com/urtho.png" width="60px" alt="Paweł Pierścionek" /></a>
 <a href="https://github.com/monocursive"><img src="https://github.com/monocursive.png" width="60px" alt="Michael Mazurczak" /></a>
 <a href="https://formbricks.com/?utm_source=coolify.io"><img src="https://github.com/formbricks.png" width="60px" alt="Formbricks" /></a>
-<a href="https://x.com/adithsuhas17?utm_source=coolify.io"><img src="https://github.com/adith-suhas-sv.png" width="60px" alt="Adith Suhas" /></a>
+<a href="https://startupfa.me?utm_source=coolify.io"><img src="https://github.com/startupfame.png" width="60px" alt="StartupFame" /></a>
+<a href="https://jonasjaeger.com?utm_source=coolify.io"><img src="https://github.com/toxin20.png" width="60px" alt="Jonas Jaeger" /></a>
+<a href="https://github.com/therealjp?utm_source=coolify.io"><img src="https://github.com/therealjp.png" width="60px" alt="JP" /></a>
+<a href="https://evercam.io/?utm_source=coolify.io"><img src="https://github.com/evercam.png" width="60px" alt="Evercam" /></a>
+<a href="https://web3.career/?utm_source=coolify.io"><img src="https://web3.career/favicon1.png" width="60px" alt="Web3 Career" /></a>
 
 ## Organizations
 <a href="https://opencollective.com/coollabsio/organization/0/website"><img src="https://opencollective.com/coollabsio/organization/0/avatar.svg"></a>
@@ -121,7 +129,6 @@ ## Why should I use the Cloud version?
 - Better support
 - Less maintenance for you
 
-
 # Recognitions
 
 <p>
@@ -138,6 +145,13 @@ # Recognitions
 
 <a href="https://trendshift.io/repositories/634" target="_blank"><img src="https://trendshift.io/api/badge/repositories/634" alt="coollabsio%2Fcoolify | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 
+# Core Maintainers
+
+| Andras Bacsai | 🏔️ Peak |
+|------------|------------|
+| <img src="https://github.com/andrasbacsai.png" width="200px" alt="Andras Bacsai" /> | <img src="https://github.com/peaklabs-dev.png" width="200px" alt="peaklabs-dev" /> |
+| <a href="https://github.com/andrasbacsai"><img src="https://api.iconify.design/devicon:github.svg" width="25px"></a> <a href="https://x.com/heyandras"><img src="https://api.iconify.design/devicon:twitter.svg" width="25px"></a> <a href="https://bsky.app/profile/heyandras.dev"><img src="https://api.iconify.design/simple-icons:bluesky.svg" width="25px"></a> | <a href="https://github.com/peaklabs-dev"><img src="https://api.iconify.design/devicon:github.svg" width="25px"></a> <a href="https://x.com/peaklabs_dev"><img src="https://api.iconify.design/devicon:twitter.svg" width="25px"></a> <a href="https://bsky.app/profile/peaklabs.dev"><img src="https://api.iconify.design/simple-icons:bluesky.svg" width="25px"></a> |
+
 # Repo Activity
 
 ![Alt](https://repobeats.axiom.co/api/embed/eab1c8066f9c59d0ad37b76c23ebb5ccac4278ae.svg "Repobeats analytics image")

RELEASE.md

@@ -1,6 +1,6 @@
 # Coolify Release Guide
 
-This guide outlines the release process for Coolify, intended for developers and those interested in understanding how releases are managed and deployed.
+This guide outlines the release process for Coolify, intended for developers and those interested in understanding how Coolify releases are managed and deployed.
 
 ## Table of Contents
 - [Release Process](#release-process)
@@ -19,19 +19,19 @@ ## Release Process
    - Improvements, fixes, and new features are developed on the `next` branch or separate feature branches.
 
 2. **Merging to `main`**
-   - Once ready, changes are merged from the `next` branch into the `main` branch.
+   - Once ready, changes are merged from the `next` branch into the `main` branch (via a pull request).
 
 3. **Building the Release**
-   - After merging to `main`, GitHub Actions automatically builds release images for all architectures and pushes them to the GitHub Container Registry with the version tag and the `latest` tag.
+   - After merging to `main`, GitHub Actions automatically builds release images for all architectures and pushes them to the GitHub Container Registry and Docker Hub with the specific version tag and the `latest` tag.
 
 4. **Creating a GitHub Release**
    - A new GitHub release is manually created with details of the changes made in the version.
 
 5. **Updating the CDN**
-   - To make a new version publicly available, the version information on the CDN needs to be updated: [https://cdn.coollabs.io/coolify/versions.json](https://cdn.coollabs.io/coolify/versions.json)
+   - To make a new version publicly available, the version information on the CDN needs to be updated manually. After that the new version number will be available at [https://cdn.coollabs.io/coolify/versions.json](https://cdn.coollabs.io/coolify/versions.json).
 
 > [!NOTE]
-> The CDN update may not occur immediately after the GitHub release. It can take hours or even days due to additional testing, stability checks, or potential hotfixes. **The update becomes available only after the CDN is updated.**
+> The CDN update may not occur immediately after the GitHub release. It can take hours or even days due to additional testing, stability checks, or potential hotfixes. **The update becomes available only after the CDN is updated. After the CDN is updated, a discord announcement will be made in the Production Release channel.**
 
 ## Version Types
 
@@ -39,10 +39,10 @@ ## Version Types
   <summary><strong>Stable (coming soon)</strong></summary>
 
 - **Stable**
-  - The production version suitable for stable, production environments (generally recommended).
-  - **Update Frequency:** Every 2 to 4 weeks, with more frequent possible hotfixes.
+  - The production version suitable for stable, production environments (recommended).
+  - **Update Frequency:** Every 2 to 4 weeks, with more frequent possible fixes.
   - **Release Size:** Larger but less frequent releases. Multiple nightly versions are consolidated into a single stable release.
-  - **Versioning Scheme:** Follows semantic versioning (e.g., `v4.0.0`).
+  - **Versioning Scheme:** Follows semantic versioning (e.g., `v4.0.0`, `4.1.0`, etc.).
   - **Installation Command:**
     ```bash
     curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
@@ -57,7 +57,7 @@ ## Version Types
   - The latest development version, suitable for testing the latest changes and experimenting with new features.
   - **Update Frequency:** Daily or bi-weekly updates.
   - **Release Size:** Smaller, more frequent releases.
-  - **Versioning Scheme:** TO BE DETERMINED
+  - **Versioning Scheme:** Follows semantic versioning (e.g., `4.1.0-nightly.1`, `4.1.0-nightly.2`, etc.).
   - **Installation Command:**
     ```bash
     curl -fsSL https://cdn.coollabs.io/coolify-nightly/install.sh | bash -s next
@@ -73,11 +73,11 @@ ## Version Types
   - **Purpose:** Allows users to test and provide feedback on new features and changes before they become stable.
   - **Update Frequency:** Available if we think beta testing is necessary.
   - **Release Size:** Same size as stable release as it will become the next stabe release after some time.
-  - **Versioning Scheme:** Follows semantic versioning (e.g., `4.1.0-beta.1`).
+  - **Versioning Scheme:** Follows semantic versioning (e.g., `4.1.0-beta.1`, `4.1.0-beta.2`, etc.).
   - **Installation Command:**
-    ```bash
+  ```bash
     curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
-    ```
+  ```
 
 </details>
 
@@ -117,12 +117,15 @@ ### Cloud
 > [!IMPORTANT]
 > The cloud version of Coolify may be several versions behind the latest GitHub releases even if the CDN is updated. This is intentional to ensure stability and reliability for cloud users and Andras will manully update the cloud version when the update is ready.
 
-## Manually Update to Specific Versions
+## Manually Update/ Downgrade to Specific Versions
 
 > [!CAUTION]  
-> Updating to unreleased versions is not recommended and may cause issues. Use at your own risk!
+> Updating to unreleased versions is not recommended and can cause issues.
 
-To update your Coolify instance to a specific (unreleased) version, use the following command:
+> [!IMPORTANT]
+> Downgrading is supported but not recommended and can cause issues because of database migrations and other changes.
+
+To update your Coolify instance to a specific version, use the following command:
 
 ```bash
 curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash -s <version>

SECURITY.md

@@ -2,15 +2,24 @@ # Security Policy
 
 ## Supported Versions
 
-Use this section to tell people about which versions of your project are
-currently being supported with security updates.
+Currently supported, maintained and updated versions:
 
-| Version | Supported          |
-| ------- | ------------------ |
-| > 4   | :white_check_mark: |
-| 3   | :x:                |
+| Version | Supported          | Support Status |
+| ------- | ------------------ | -------------- |
+| 4.x     | :white_check_mark: | Active Development & Security Updates |
+| < 4.0   | :x:                | End of Life (no security updates) |
 
+## Security Updates
+
+We take security seriously. Security updates are released as soon as possible after a vulnerability is discovered and verified.
 
 ## Reporting a Vulnerability
 
-If you have any vulnerability please report at hi@coollabs.io
+If you discover a security vulnerability, please follow these steps:
+
+1. **DO NOT** disclose the vulnerability publicly.
+2. Send a detailed report to: `hi@coollabs.io`.
+3. Include in your report:
+   - A description of the vulnerability
+   - Steps to reproduce the issue
+   - Potential impact

app/Actions/Application/GenerateConfig.php

@@ -11,7 +11,6 @@ class GenerateConfig
 
     public function handle(Application $application, bool $is_json = false)
     {
-        ray()->clearAll();
         return $application->generateConfig(is_json: $is_json);
     }
 }

app/Actions/Application/IsHorizonQueueEmpty.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Actions\Application;
+
+use Laravel\Horizon\Contracts\JobRepository;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class IsHorizonQueueEmpty
+{
+    use AsAction;
+
+    public function handle()
+    {
+        $hostname = gethostname();
+        $recent = app(JobRepository::class)->getRecent();
+        if ($recent) {
+            $running = $recent->filter(function ($job) use ($hostname) {
+                $payload = json_decode($job->payload);
+                $tags = data_get($payload, 'tags');
+
+                return $job->status != 'completed' &&
+                       $job->status != 'failed' &&
+                       isset($tags) &&
+                       is_array($tags) &&
+                       in_array('server:'.$hostname, $tags);
+            });
+            if ($running->count() > 0) {
+                echo 'false';
+
+                return false;
+            }
+        }
+        echo 'true';
+
+        return true;
+    }
+}

app/Actions/Application/StopApplication.php

@@ -10,6 +10,8 @@ class StopApplication
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public function handle(Application $application, bool $previewDeployments = false, bool $dockerCleanup = true)
     {
         try {
@@ -17,7 +19,6 @@ public function handle(Application $application, bool $previewDeployments = fals
             if (! $server->isFunctional()) {
                 return 'Server is not functional';
             }
-            ray('Stopping application: '.$application->name);
 
             if ($server->isSwarm()) {
                 instant_remote_process(["docker stack rm {$application->uuid}"], $server);
@@ -36,8 +37,6 @@ public function handle(Application $application, bool $previewDeployments = fals
                 CleanupDocker::dispatch($server, true);
             }
         } catch (\Exception $e) {
-            ray($e->getMessage());
-
             return $e->getMessage();
         }
     }

app/Actions/Application/StopApplicationOneServer.php

@@ -32,8 +32,6 @@ public function handle(Application $application, Server $server)
                 }
             }
         } catch (\Exception $e) {
-            ray($e->getMessage());
-
             return $e->getMessage();
         }
     }

app/Actions/CoolifyTask/PrepareCoolifyTask.php

@@ -3,7 +3,6 @@
 namespace App\Actions\CoolifyTask;
 
 use App\Data\CoolifyTaskArgs;
-use App\Enums\ActivityTypes;
 use App\Jobs\CoolifyTask;
 use Spatie\Activitylog\Models\Activity;
 
@@ -47,12 +46,7 @@ public function __invoke(): Activity
             call_event_on_finish: $this->remoteProcessArgs->call_event_on_finish,
             call_event_data: $this->remoteProcessArgs->call_event_data,
         );
-        if ($this->remoteProcessArgs->type === ActivityTypes::COMMAND->value) {
-            ray('Dispatching a high priority job');
-            dispatch($job)->onQueue('high');
-        } else {
-            dispatch($job);
-        }
+        dispatch($job);
         $this->activity->refresh();
 
         return $this->activity;

app/Actions/CoolifyTask/RunRemoteProcess.php

@@ -9,6 +9,7 @@
 use App\Models\Server;
 use Illuminate\Process\ProcessResult;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Facades\Process;
 use Spatie\Activitylog\Models\Activity;
 
@@ -39,7 +40,6 @@ class RunRemoteProcess
      */
     public function __construct(Activity $activity, bool $hide_from_output = false, bool $ignore_errors = false, $call_event_on_finish = null, $call_event_data = null)
     {
-
         if ($activity->getExtraProperty('type') !== ActivityTypes::INLINE->value && $activity->getExtraProperty('type') !== ActivityTypes::COMMAND->value) {
             throw new \RuntimeException('Incompatible Activity to run a remote command.');
         }
@@ -125,7 +125,7 @@ public function __invoke(): ProcessResult
                     ]));
                 }
             } catch (\Throwable $e) {
-                ray($e);
+                Log::error('Error calling event: '.$e->getMessage());
             }
         }
 

app/Actions/Database/StartClickhouse.php

@@ -24,7 +24,7 @@ public function handle(StandaloneClickhouse $database)
         $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
-            "echo 'Starting {$database->name}.'",
+            "echo 'Starting database.'",
             "mkdir -p $this->configuration_dir",
         ];
 
@@ -51,6 +51,8 @@ public function handle(StandaloneClickhouse $database)
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => "clickhouse-client --password {$this->database->clickhouse_admin_password} --query 'SELECT 1'",
@@ -97,8 +99,8 @@ public function handle(StandaloneClickhouse $database)
         }
 
         // Add custom docker run options
-        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
-        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
 
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);

app/Actions/Database/StartDatabase.php

@@ -16,6 +16,8 @@ class StartDatabase
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database)
     {
         $server = $database->destination->server;
@@ -23,28 +25,28 @@ public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|St
             return 'Server is not functional';
         }
         switch ($database->getMorphClass()) {
-            case 'App\Models\StandalonePostgresql':
+            case \App\Models\StandalonePostgresql::class:
                 $activity = StartPostgresql::run($database);
                 break;
-            case 'App\Models\StandaloneRedis':
+            case \App\Models\StandaloneRedis::class:
                 $activity = StartRedis::run($database);
                 break;
-            case 'App\Models\StandaloneMongodb':
+            case \App\Models\StandaloneMongodb::class:
                 $activity = StartMongodb::run($database);
                 break;
-            case 'App\Models\StandaloneMysql':
+            case \App\Models\StandaloneMysql::class:
                 $activity = StartMysql::run($database);
                 break;
-            case 'App\Models\StandaloneMariadb':
+            case \App\Models\StandaloneMariadb::class:
                 $activity = StartMariadb::run($database);
                 break;
-            case 'App\Models\StandaloneKeydb':
+            case \App\Models\StandaloneKeydb::class:
                 $activity = StartKeydb::run($database);
                 break;
-            case 'App\Models\StandaloneDragonfly':
+            case \App\Models\StandaloneDragonfly::class:
                 $activity = StartDragonfly::run($database);
                 break;
-            case 'App\Models\StandaloneClickhouse':
+            case \App\Models\StandaloneClickhouse::class:
                 $activity = StartClickhouse::run($database);
                 break;
         }

app/Actions/Database/StartDatabaseProxy.php

@@ -18,6 +18,8 @@ class StartDatabaseProxy
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse|ServiceDatabase $database)
     {
         $internalPort = null;
@@ -26,7 +28,7 @@ public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|St
         $server = data_get($database, 'destination.server');
         $containerName = data_get($database, 'uuid');
         $proxyContainerName = "{$database->uuid}-proxy";
-        if ($database->getMorphClass() === 'App\Models\ServiceDatabase') {
+        if ($database->getMorphClass() === \App\Models\ServiceDatabase::class) {
             $databaseType = $database->databaseType();
             // $connectPredefined = data_get($database, 'service.connect_to_docker_network');
             $network = $database->service->uuid;
@@ -34,54 +36,54 @@ public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|St
             $proxyContainerName = "{$database->service->uuid}-proxy";
             switch ($databaseType) {
                 case 'standalone-mariadb':
-                    $type = 'App\Models\StandaloneMariadb';
+                    $type = \App\Models\StandaloneMariadb::class;
                     $containerName = "mariadb-{$database->service->uuid}";
                     break;
                 case 'standalone-mongodb':
-                    $type = 'App\Models\StandaloneMongodb';
+                    $type = \App\Models\StandaloneMongodb::class;
                     $containerName = "mongodb-{$database->service->uuid}";
                     break;
                 case 'standalone-mysql':
-                    $type = 'App\Models\StandaloneMysql';
+                    $type = \App\Models\StandaloneMysql::class;
                     $containerName = "mysql-{$database->service->uuid}";
                     break;
                 case 'standalone-postgresql':
-                    $type = 'App\Models\StandalonePostgresql';
+                    $type = \App\Models\StandalonePostgresql::class;
                     $containerName = "postgresql-{$database->service->uuid}";
                     break;
                 case 'standalone-redis':
-                    $type = 'App\Models\StandaloneRedis';
+                    $type = \App\Models\StandaloneRedis::class;
                     $containerName = "redis-{$database->service->uuid}";
                     break;
                 case 'standalone-keydb':
-                    $type = 'App\Models\StandaloneKeydb';
+                    $type = \App\Models\StandaloneKeydb::class;
                     $containerName = "keydb-{$database->service->uuid}";
                     break;
                 case 'standalone-dragonfly':
-                    $type = 'App\Models\StandaloneDragonfly';
+                    $type = \App\Models\StandaloneDragonfly::class;
                     $containerName = "dragonfly-{$database->service->uuid}";
                     break;
                 case 'standalone-clickhouse':
-                    $type = 'App\Models\StandaloneClickhouse';
+                    $type = \App\Models\StandaloneClickhouse::class;
                     $containerName = "clickhouse-{$database->service->uuid}";
                     break;
             }
         }
-        if ($type === 'App\Models\StandaloneRedis') {
+        if ($type === \App\Models\StandaloneRedis::class) {
             $internalPort = 6379;
-        } elseif ($type === 'App\Models\StandalonePostgresql') {
+        } elseif ($type === \App\Models\StandalonePostgresql::class) {
             $internalPort = 5432;
-        } elseif ($type === 'App\Models\StandaloneMongodb') {
+        } elseif ($type === \App\Models\StandaloneMongodb::class) {
             $internalPort = 27017;
-        } elseif ($type === 'App\Models\StandaloneMysql') {
+        } elseif ($type === \App\Models\StandaloneMysql::class) {
             $internalPort = 3306;
-        } elseif ($type === 'App\Models\StandaloneMariadb') {
+        } elseif ($type === \App\Models\StandaloneMariadb::class) {
             $internalPort = 3306;
-        } elseif ($type === 'App\Models\StandaloneKeydb') {
+        } elseif ($type === \App\Models\StandaloneKeydb::class) {
             $internalPort = 6379;
-        } elseif ($type === 'App\Models\StandaloneDragonfly') {
+        } elseif ($type === \App\Models\StandaloneDragonfly::class) {
             $internalPort = 6379;
-        } elseif ($type === 'App\Models\StandaloneClickhouse') {
+        } elseif ($type === \App\Models\StandaloneClickhouse::class) {
             $internalPort = 9000;
         }
         $configuration_dir = database_proxy_dir($database->uuid);

app/Actions/Database/StartDragonfly.php

@@ -26,7 +26,7 @@ public function handle(StandaloneDragonfly $database)
         $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
-            "echo 'Starting {$database->name}.'",
+            "echo 'Starting database.'",
             "mkdir -p $this->configuration_dir",
         ];
 
@@ -48,6 +48,8 @@ public function handle(StandaloneDragonfly $database)
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => "redis-cli -a {$this->database->dragonfly_password} ping",
@@ -94,8 +96,8 @@ public function handle(StandaloneDragonfly $database)
         }
 
         // Add custom docker run options
-        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
-        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
 
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);

app/Actions/Database/StartKeydb.php

@@ -27,7 +27,7 @@ public function handle(StandaloneKeydb $database)
         $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
-            "echo 'Starting {$database->name}.'",
+            "echo 'Starting database.'",
             "mkdir -p $this->configuration_dir",
         ];
 
@@ -50,6 +50,8 @@ public function handle(StandaloneKeydb $database)
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => "keydb-cli --pass {$this->database->keydb_password} ping",
@@ -105,8 +107,8 @@ public function handle(StandaloneKeydb $database)
         }
 
         // Add custom docker run options
-        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
-        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);
         $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";

app/Actions/Database/StartMariadb.php

@@ -24,7 +24,7 @@ public function handle(StandaloneMariadb $database)
         $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
-            "echo 'Starting {$database->name}.'",
+            "echo 'Starting database.'",
             "mkdir -p $this->configuration_dir",
         ];
 
@@ -45,6 +45,8 @@ public function handle(StandaloneMariadb $database)
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => ['CMD', 'healthcheck.sh', '--connect', '--innodb_initialized'],
@@ -99,8 +101,8 @@ public function handle(StandaloneMariadb $database)
         }
 
         // Add custom docker run options
-        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
-        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
 
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);

app/Actions/Database/StartMongodb.php

@@ -25,8 +25,12 @@ public function handle(StandaloneMongodb $database)
         $container_name = $this->database->uuid;
         $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
+        if (isDev()) {
+            $this->configuration_dir = '/var/lib/docker/volumes/coolify_dev_coolify_data/_data/databases/'.$container_name;
+        }
+
         $this->commands = [
-            "echo 'Starting {$database->name}.'",
+            "echo 'Starting database.'",
             "mkdir -p $this->configuration_dir",
         ];
 
@@ -49,6 +53,8 @@ public function handle(StandaloneMongodb $database)
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => [
@@ -115,8 +121,8 @@ public function handle(StandaloneMongodb $database)
         ];
 
         // Add custom docker run options
-        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
-        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
 
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);

app/Actions/Database/StartMysql.php

@@ -24,7 +24,7 @@ public function handle(StandaloneMysql $database)
         $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
-            "echo 'Starting {$database->name}.'",
+            "echo 'Starting database.'",
             "mkdir -p $this->configuration_dir",
         ];
 
@@ -45,6 +45,8 @@ public function handle(StandaloneMysql $database)
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => ['CMD', 'mysqladmin', 'ping', '-h', 'localhost', '-u', 'root', "-p{$this->database->mysql_root_password}"],
@@ -99,8 +101,8 @@ public function handle(StandaloneMysql $database)
         }
 
         // Add custom docker run options
-        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
-        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
 
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);

app/Actions/Database/StartPostgresql.php

@@ -25,7 +25,7 @@ public function handle(StandalonePostgresql $database)
         $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
-            "echo 'Starting {$database->name}.'",
+            "echo 'Starting database.'",
             "mkdir -p $this->configuration_dir",
             "mkdir -p $this->configuration_dir/docker-entrypoint-initdb.d/",
         ];
@@ -49,6 +49,8 @@ public function handle(StandalonePostgresql $database)
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => [
@@ -120,8 +122,8 @@ public function handle(StandalonePostgresql $database)
             ];
         }
         // Add custom docker run options
-        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
-        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
 
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);

app/Actions/Database/StartRedis.php

@@ -21,13 +21,11 @@ public function handle(StandaloneRedis $database)
     {
         $this->database = $database;
 
-        $startCommand = "redis-server --requirepass {$this->database->redis_password} --appendonly yes";
-
         $container_name = $this->database->uuid;
         $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
-            "echo 'Starting {$database->name}.'",
+            "echo 'Starting database.'",
             "mkdir -p $this->configuration_dir",
         ];
 
@@ -37,6 +35,8 @@ public function handle(StandaloneRedis $database)
         $environment_variables = $this->generate_environment_variables();
         $this->add_custom_redis();
 
+        $startCommand = $this->buildStartCommand();
+
         $docker_compose = [
             'services' => [
                 $container_name => [
@@ -50,6 +50,8 @@ public function handle(StandaloneRedis $database)
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => [
@@ -105,12 +107,11 @@ public function handle(StandaloneRedis $database)
                 'target' => '/usr/local/etc/redis/redis.conf',
                 'read_only' => true,
             ];
-            $docker_compose['services'][$container_name]['command'] = "redis-server /usr/local/etc/redis/redis.conf --requirepass {$this->database->redis_password} --appendonly yes";
         }
 
         // Add custom docker run options
-        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
-        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
 
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);
@@ -160,12 +161,26 @@ private function generate_local_persistent_volumes_only_volume_names()
     private function generate_environment_variables()
     {
         $environment_variables = collect();
-        foreach ($this->database->runtime_environment_variables as $env) {
-            $environment_variables->push("$env->key=$env->real_value");
-        }
 
-        if ($environment_variables->filter(fn ($env) => str($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
-            $environment_variables->push("REDIS_PASSWORD={$this->database->redis_password}");
+        foreach ($this->database->runtime_environment_variables as $env) {
+            if ($env->is_shared) {
+                $environment_variables->push("$env->key=$env->real_value");
+
+                if ($env->key === 'REDIS_PASSWORD') {
+                    $this->database->update(['redis_password' => $env->real_value]);
+                }
+
+                if ($env->key === 'REDIS_USERNAME') {
+                    $this->database->update(['redis_username' => $env->real_value]);
+                }
+            } else {
+                if ($env->key === 'REDIS_PASSWORD') {
+                    $env->update(['value' => $this->database->redis_password]);
+                } elseif ($env->key === 'REDIS_USERNAME') {
+                    $env->update(['value' => $this->database->redis_username]);
+                }
+                $environment_variables->push("$env->key=$env->real_value");
+            }
         }
 
         add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
@@ -173,6 +188,27 @@ private function generate_environment_variables()
         return $environment_variables->all();
     }
 
+    private function buildStartCommand(): string
+    {
+        $hasRedisConf = ! is_null($this->database->redis_conf) && ! empty($this->database->redis_conf);
+        $redisConfPath = '/usr/local/etc/redis/redis.conf';
+
+        if ($hasRedisConf) {
+            $confContent = $this->database->redis_conf;
+            $hasRequirePass = str_contains($confContent, 'requirepass');
+
+            if ($hasRequirePass) {
+                $command = "redis-server $redisConfPath";
+            } else {
+                $command = "redis-server $redisConfPath --requirepass {$this->database->redis_password}";
+            }
+        } else {
+            $command = "redis-server --requirepass {$this->database->redis_password} --appendonly yes";
+        }
+
+        return $command;
+    }
+
     private function add_custom_redis()
     {
         if (is_null($this->database->redis_conf) || empty($this->database->redis_conf)) {

app/Actions/Database/StopDatabaseProxy.php

@@ -2,7 +2,7 @@
 
 namespace App\Actions\Database;
 
-use App\Events\DatabaseStatusChanged;
+use App\Events\DatabaseProxyStopped;
 use App\Models\ServiceDatabase;
 use App\Models\StandaloneClickhouse;
 use App\Models\StandaloneDragonfly;
@@ -18,16 +18,22 @@ class StopDatabaseProxy
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|ServiceDatabase|StandaloneDragonfly|StandaloneClickhouse $database)
     {
         $server = data_get($database, 'destination.server');
         $uuid = $database->uuid;
-        if ($database->getMorphClass() === 'App\Models\ServiceDatabase') {
+        if ($database->getMorphClass() === \App\Models\ServiceDatabase::class) {
             $uuid = $database->service->uuid;
             $server = data_get($database, 'service.server');
         }
         instant_remote_process(["docker rm -f {$uuid}-proxy"], $server);
+
+        $database->is_public = false;
         $database->save();
-        DatabaseStatusChanged::dispatch();
+
+        DatabaseProxyStopped::dispatch();
+
     }
 }

app/Actions/Docker/GetContainersStatus.php

@@ -3,14 +3,10 @@
 namespace App\Actions\Docker;
 
 use App\Actions\Database\StartDatabaseProxy;
-use App\Actions\Proxy\CheckProxy;
-use App\Actions\Proxy\StartProxy;
 use App\Actions\Shared\ComplexStatusCheck;
 use App\Models\ApplicationPreview;
 use App\Models\Server;
 use App\Models\ServiceDatabase;
-use App\Notifications\Container\ContainerRestarted;
-use App\Notifications\Container\ContainerStopped;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Collection;
 use Lorisleiva\Actions\Concerns\AsAction;
@@ -19,6 +15,8 @@ class GetContainersStatus
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public $applications;
 
     public ?Collection $containers;
@@ -33,7 +31,7 @@ public function handle(Server $server, ?Collection $containers = null, ?Collecti
         $this->containerReplicates = $containerReplicates;
         $this->server = $server;
         if (! $this->server->isFunctional()) {
-            return 'Server is not ready.';
+            return 'Server is not functional.';
         }
         $this->applications = $this->server->applications();
         $skip_these_applications = collect([]);
@@ -49,323 +47,8 @@ public function handle(Server $server, ?Collection $containers = null, ?Collecti
         $this->applications = $this->applications->filter(function ($value, $key) use ($skip_these_applications) {
             return ! $skip_these_applications->pluck('id')->contains($value->id);
         });
-        $this->old_way();
-        // if ($this->server->isSwarm()) {
-        //     $this->old_way();
-        // } else {
-        //     if (!$this->server->is_metrics_enabled) {
-        //         $this->old_way();
-        //         return;
-        //     }
-        //     $sentinel_found = instant_remote_process(["docker inspect coolify-sentinel"], $this->server, false);
-        //     $sentinel_found = json_decode($sentinel_found, true);
-        //     $status = data_get($sentinel_found, '0.State.Status', 'exited');
-        //     if ($status === 'running') {
-        //         ray('Checking with Sentinel');
-        //         $this->sentinel();
-        //     } else {
-        //         ray('Checking the Old way');
-        //         $this->old_way();
-        //     }
-        // }
-    }
-
-    // private function sentinel()
-    // {
-    //     try {
-    //         $this->containers = $this->server->getContainersWithSentinel();
-    //         if ($this->containers->count() === 0) {
-    //             return;
-    //         }
-    //         $databases = $this->server->databases();
-    //         $services = $this->server->services()->get();
-    //         $previews = $this->server->previews();
-    //         $foundApplications = [];
-    //         $foundApplicationPreviews = [];
-    //         $foundDatabases = [];
-    //         $foundServices = [];
-
-    //         foreach ($this->containers as $container) {
-    //             $labels = Arr::undot(data_get($container, 'labels'));
-    //             $containerStatus = data_get($container, 'state');
-    //             $containerHealth = data_get($container, 'health_status', 'unhealthy');
-    //             $containerStatus = "$containerStatus ($containerHealth)";
-    //             $applicationId = data_get($labels, 'coolify.applicationId');
-    //             if ($applicationId) {
-    //                 $pullRequestId = data_get($labels, 'coolify.pullRequestId');
-    //                 if ($pullRequestId) {
-    //                     if (str($applicationId)->contains('-')) {
-    //                         $applicationId = str($applicationId)->before('-');
-    //                     }
-    //                     $preview = ApplicationPreview::where('application_id', $applicationId)->where('pull_request_id', $pullRequestId)->first();
-    //                     if ($preview) {
-    //                         $foundApplicationPreviews[] = $preview->id;
-    //                         $statusFromDb = $preview->status;
-    //                         if ($statusFromDb !== $containerStatus) {
-    //                             $preview->update(['status' => $containerStatus]);
-    //                         }
-    //                     } else {
-    //                         //Notify user that this container should not be there.
-    //                     }
-    //                 } else {
-    //                     $application = $this->applications->where('id', $applicationId)->first();
-    //                     if ($application) {
-    //                         $foundApplications[] = $application->id;
-    //                         $statusFromDb = $application->status;
-    //                         if ($statusFromDb !== $containerStatus) {
-    //                             $application->update(['status' => $containerStatus]);
-    //                         }
-    //                     } else {
-    //                         //Notify user that this container should not be there.
-    //                     }
-    //                 }
-    //             } else {
-    //                 $uuid = data_get($labels, 'com.docker.compose.service');
-    //                 $type = data_get($labels, 'coolify.type');
-    //                 if ($uuid) {
-    //                     if ($type === 'service') {
-    //                         $database_id = data_get($labels, 'coolify.service.subId');
-    //                         if ($database_id) {
-    //                             $service_db = ServiceDatabase::where('id', $database_id)->first();
-    //                             if ($service_db) {
-    //                                 $uuid = $service_db->service->uuid;
-    //                                 $isPublic = data_get($service_db, 'is_public');
-    //                                 if ($isPublic) {
-    //                                     $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
-    //                                         if ($this->server->isSwarm()) {
-    //                                             // TODO: fix this with sentinel
-    //                                             return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
-    //                                         } else {
-    //                                             return data_get($value, 'name') === "$uuid-proxy";
-    //                                         }
-    //                                     })->first();
-    //                                     if (! $foundTcpProxy) {
-    //                                         StartDatabaseProxy::run($service_db);
-    //                                         // $this->server->team?->notify(new ContainerRestarted("TCP Proxy for {$service_db->service->name}", $this->server));
-    //                                     }
-    //                                 }
-    //                             }
-    //                         }
-    //                     } else {
-    //                         $database = $databases->where('uuid', $uuid)->first();
-    //                         if ($database) {
-    //                             $isPublic = data_get($database, 'is_public');
-    //                             $foundDatabases[] = $database->id;
-    //                             $statusFromDb = $database->status;
-    //                             if ($statusFromDb !== $containerStatus) {
-    //                                 $database->update(['status' => $containerStatus]);
-    //                             }
-    //                             if ($isPublic) {
-    //                                 $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
-    //                                     if ($this->server->isSwarm()) {
-    //                                         // TODO: fix this with sentinel
-    //                                         return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
-    //                                     } else {
-    //                                         return data_get($value, 'name') === "$uuid-proxy";
-    //                                     }
-    //                                 })->first();
-    //                                 if (! $foundTcpProxy) {
-    //                                     StartDatabaseProxy::run($database);
-    //                                     $this->server->team?->notify(new ContainerRestarted("TCP Proxy for {$database->name}", $this->server));
-    //                                 }
-    //                             }
-    //                         } else {
-    //                             // Notify user that this container should not be there.
-    //                         }
-    //                     }
-    //                 }
-    //                 if (data_get($container, 'name') === 'coolify-db') {
-    //                     $foundDatabases[] = 0;
-    //                 }
-    //             }
-    //             $serviceLabelId = data_get($labels, 'coolify.serviceId');
-    //             if ($serviceLabelId) {
-    //                 $subType = data_get($labels, 'coolify.service.subType');
-    //                 $subId = data_get($labels, 'coolify.service.subId');
-    //                 $service = $services->where('id', $serviceLabelId)->first();
-    //                 if (! $service) {
-    //                     continue;
-    //                 }
-    //                 if ($subType === 'application') {
-    //                     $service = $service->applications()->where('id', $subId)->first();
-    //                 } else {
-    //                     $service = $service->databases()->where('id', $subId)->first();
-    //                 }
-    //                 if ($service) {
-    //                     $foundServices[] = "$service->id-$service->name";
-    //                     $statusFromDb = $service->status;
-    //                     if ($statusFromDb !== $containerStatus) {
-    //                         // ray('Updating status: ' . $containerStatus);
-    //                         $service->update(['status' => $containerStatus]);
-    //                     }
-    //                 }
-    //             }
-    //         }
-    //         $exitedServices = collect([]);
-    //         foreach ($services as $service) {
-    //             $apps = $service->applications()->get();
-    //             $dbs = $service->databases()->get();
-    //             foreach ($apps as $app) {
-    //                 if (in_array("$app->id-$app->name", $foundServices)) {
-    //                     continue;
-    //                 } else {
-    //                     $exitedServices->push($app);
-    //                 }
-    //             }
-    //             foreach ($dbs as $db) {
-    //                 if (in_array("$db->id-$db->name", $foundServices)) {
-    //                     continue;
-    //                 } else {
-    //                     $exitedServices->push($db);
-    //                 }
-    //             }
-    //         }
-    //         $exitedServices = $exitedServices->unique('id');
-    //         foreach ($exitedServices as $exitedService) {
-    //             if (str($exitedService->status)->startsWith('exited')) {
-    //                 continue;
-    //             }
-    //             $name = data_get($exitedService, 'name');
-    //             $fqdn = data_get($exitedService, 'fqdn');
-    //             if ($name) {
-    //                 if ($fqdn) {
-    //                     $containerName = "$name, available at $fqdn";
-    //                 } else {
-    //                     $containerName = $name;
-    //                 }
-    //             } else {
-    //                 if ($fqdn) {
-    //                     $containerName = $fqdn;
-    //                 } else {
-    //                     $containerName = null;
-    //                 }
-    //             }
-    //             $projectUuid = data_get($service, 'environment.project.uuid');
-    //             $serviceUuid = data_get($service, 'uuid');
-    //             $environmentName = data_get($service, 'environment.name');
-
-    //             if ($projectUuid && $serviceUuid && $environmentName) {
-    //                 $url = base_url().'/project/'.$projectUuid.'/'.$environmentName.'/service/'.$serviceUuid;
-    //             } else {
-    //                 $url = null;
-    //             }
-    //             // $this->server->team?->notify(new ContainerStopped($containerName, $this->server, $url));
-    //             $exitedService->update(['status' => 'exited']);
-    //         }
-
-    //         $notRunningApplications = $this->applications->pluck('id')->diff($foundApplications);
-    //         foreach ($notRunningApplications as $applicationId) {
-    //             $application = $this->applications->where('id', $applicationId)->first();
-    //             if (str($application->status)->startsWith('exited')) {
-    //                 continue;
-    //             }
-    //             $application->update(['status' => 'exited']);
-
-    //             $name = data_get($application, 'name');
-    //             $fqdn = data_get($application, 'fqdn');
-
-    //             $containerName = $name ? "$name ($fqdn)" : $fqdn;
-
-    //             $projectUuid = data_get($application, 'environment.project.uuid');
-    //             $applicationUuid = data_get($application, 'uuid');
-    //             $environment = data_get($application, 'environment.name');
-
-    //             if ($projectUuid && $applicationUuid && $environment) {
-    //                 $url = base_url().'/project/'.$projectUuid.'/'.$environment.'/application/'.$applicationUuid;
-    //             } else {
-    //                 $url = null;
-    //             }
-
-    //             // $this->server->team?->notify(new ContainerStopped($containerName, $this->server, $url));
-    //         }
-    //         $notRunningApplicationPreviews = $previews->pluck('id')->diff($foundApplicationPreviews);
-    //         foreach ($notRunningApplicationPreviews as $previewId) {
-    //             $preview = $previews->where('id', $previewId)->first();
-    //             if (str($preview->status)->startsWith('exited')) {
-    //                 continue;
-    //             }
-    //             $preview->update(['status' => 'exited']);
-
-    //             $name = data_get($preview, 'name');
-    //             $fqdn = data_get($preview, 'fqdn');
-
-    //             $containerName = $name ? "$name ($fqdn)" : $fqdn;
-
-    //             $projectUuid = data_get($preview, 'application.environment.project.uuid');
-    //             $environmentName = data_get($preview, 'application.environment.name');
-    //             $applicationUuid = data_get($preview, 'application.uuid');
-
-    //             if ($projectUuid && $applicationUuid && $environmentName) {
-    //                 $url = base_url().'/project/'.$projectUuid.'/'.$environmentName.'/application/'.$applicationUuid;
-    //             } else {
-    //                 $url = null;
-    //             }
-
-    //             // $this->server->team?->notify(new ContainerStopped($containerName, $this->server, $url));
-    //         }
-    //         $notRunningDatabases = $databases->pluck('id')->diff($foundDatabases);
-    //         foreach ($notRunningDatabases as $database) {
-    //             $database = $databases->where('id', $database)->first();
-    //             if (str($database->status)->startsWith('exited')) {
-    //                 continue;
-    //             }
-    //             $database->update(['status' => 'exited']);
-
-    //             $name = data_get($database, 'name');
-    //             $fqdn = data_get($database, 'fqdn');
-
-    //             $containerName = $name;
-
-    //             $projectUuid = data_get($database, 'environment.project.uuid');
-    //             $environmentName = data_get($database, 'environment.name');
-    //             $databaseUuid = data_get($database, 'uuid');
-
-    //             if ($projectUuid && $databaseUuid && $environmentName) {
-    //                 $url = base_url().'/project/'.$projectUuid.'/'.$environmentName.'/database/'.$databaseUuid;
-    //             } else {
-    //                 $url = null;
-    //             }
-    //             // $this->server->team?->notify(new ContainerStopped($containerName, $this->server, $url));
-    //         }
-
-    //         // Check if proxy is running
-    //         $this->server->proxyType();
-    //         $foundProxyContainer = $this->containers->filter(function ($value, $key) {
-    //             if ($this->server->isSwarm()) {
-    //                 // TODO: fix this with sentinel
-    //                 return data_get($value, 'Spec.Name') === 'coolify-proxy_traefik';
-    //             } else {
-    //                 return data_get($value, 'name') === 'coolify-proxy';
-    //             }
-    //         })->first();
-    //         if (! $foundProxyContainer) {
-    //             try {
-    //                 $shouldStart = CheckProxy::run($this->server);
-    //                 if ($shouldStart) {
-    //                     StartProxy::run($this->server, false);
-    //                     $this->server->team?->notify(new ContainerRestarted('coolify-proxy', $this->server));
-    //                 }
-    //             } catch (\Throwable $e) {
-    //                 ray($e);
-    //             }
-    //         } else {
-    //             $this->server->proxy->status = data_get($foundProxyContainer, 'state');
-    //             $this->server->save();
-    //             $connectProxyToDockerNetworks = connectProxyToNetworks($this->server);
-    //             instant_remote_process($connectProxyToDockerNetworks, $this->server, false);
-    //         }
-    //     } catch (\Exception $e) {
-    //         // send_internal_notification("ContainerStatusJob failed on ({$this->server->id}) with: " . $e->getMessage());
-    //         ray($e->getMessage());
-
-    //         return handleError($e);
-    //     }
-    // }
-
-    private function old_way()
-    {
         if ($this->containers === null) {
-            ['containers' => $this->containers,'containerReplicates' => $this->containerReplicates] = $this->server->getContainers();
+            ['containers' => $this->containers, 'containerReplicates' => $this->containerReplicates] = $this->server->getContainers();
         }
 
         if (is_null($this->containers)) {
@@ -425,6 +108,8 @@ private function old_way()
                         $statusFromDb = $preview->status;
                         if ($statusFromDb !== $containerStatus) {
                             $preview->update(['status' => $containerStatus]);
+                        } else {
+                            $preview->update(['last_online_at' => now()]);
                         }
                     } else {
                         //Notify user that this container should not be there.
@@ -436,6 +121,8 @@ private function old_way()
                         $statusFromDb = $application->status;
                         if ($statusFromDb !== $containerStatus) {
                             $application->update(['status' => $containerStatus]);
+                        } else {
+                            $application->update(['last_online_at' => now()]);
                         }
                     } else {
                         //Notify user that this container should not be there.
@@ -478,7 +165,10 @@ private function old_way()
                             $statusFromDb = $database->status;
                             if ($statusFromDb !== $containerStatus) {
                                 $database->update(['status' => $containerStatus]);
+                            } else {
+                                $database->update(['last_online_at' => now()]);
                             }
+
                             if ($isPublic) {
                                 $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
                                     if ($this->server->isSwarm()) {
@@ -489,7 +179,7 @@ private function old_way()
                                 })->first();
                                 if (! $foundTcpProxy) {
                                     StartDatabaseProxy::run($database);
-                                    $this->server->team?->notify(new ContainerRestarted("TCP Proxy for {$database->name}", $this->server));
+                                    // $this->server->team?->notify(new ContainerRestarted("TCP Proxy for database", $this->server));
                                 }
                             }
                         } else {
@@ -520,6 +210,8 @@ private function old_way()
                     if ($statusFromDb !== $containerStatus) {
                         // ray('Updating status: ' . $containerStatus);
                         $service->update(['status' => $containerStatus]);
+                    } else {
+                        $service->update(['last_online_at' => now()]);
                     }
                 }
             }
@@ -650,32 +342,5 @@ private function old_way()
             }
             // $this->server->team?->notify(new ContainerStopped($containerName, $this->server, $url));
         }
-
-        if (! $this->server->proxySet() || $this->server->proxy->force_stop) {
-            return;
-        }
-        $foundProxyContainer = $this->containers->filter(function ($value, $key) {
-            if ($this->server->isSwarm()) {
-                return data_get($value, 'Spec.Name') === 'coolify-proxy_traefik';
-            } else {
-                return data_get($value, 'Name') === '/coolify-proxy';
-            }
-        })->first();
-        if (! $foundProxyContainer) {
-            try {
-                $shouldStart = CheckProxy::run($this->server);
-                if ($shouldStart) {
-                    StartProxy::run($this->server, false);
-                    $this->server->team?->notify(new ContainerRestarted('coolify-proxy', $this->server));
-                }
-            } catch (\Throwable $e) {
-                ray($e);
-            }
-        } else {
-            $this->server->proxy->status = data_get($foundProxyContainer, 'State.Status');
-            $this->server->save();
-            $connectProxyToDockerNetworks = connectProxyToNetworks($this->server);
-            instant_remote_process($connectProxyToDockerNetworks, $this->server, false);
-        }
     }
 }

app/Actions/Fortify/CreateNewUser.php

@@ -6,12 +6,11 @@
 use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Facades\Validator;
 use Illuminate\Validation\Rule;
+use Illuminate\Validation\Rules\Password;
 use Laravel\Fortify\Contracts\CreatesNewUsers;
 
 class CreateNewUser implements CreatesNewUsers
 {
-    use PasswordValidationRules;
-
     /**
      * Validate and create a newly registered user.
      *
@@ -32,7 +31,7 @@ public function create(array $input): User
                 'max:255',
                 Rule::unique(User::class),
             ],
-            'password' => $this->passwordRules(),
+            'password' => ['required', Password::defaults(), 'confirmed'],
         ])->validate();
 
         if (User::count() == 0) {
@@ -41,7 +40,7 @@ public function create(array $input): User
             $user = User::create([
                 'id' => 0,
                 'name' => $input['name'],
-                'email' => $input['email'],
+                'email' => strtolower($input['email']),
                 'password' => Hash::make($input['password']),
             ]);
             $team = $user->teams()->first();
@@ -53,7 +52,7 @@ public function create(array $input): User
         } else {
             $user = User::create([
                 'name' => $input['name'],
-                'email' => $input['email'],
+                'email' => strtolower($input['email']),
                 'password' => Hash::make($input['password']),
             ]);
             $team = $user->teams()->first();

app/Actions/Fortify/PasswordValidationRules.php

@@ -1,18 +0,0 @@
-<?php
-
-namespace App\Actions\Fortify;
-
-use Laravel\Fortify\Rules\Password;
-
-trait PasswordValidationRules
-{
-    /**
-     * Get the validation rules used to validate passwords.
-     *
-     * @return array<int, \Illuminate\Contracts\Validation\Rule|array|string>
-     */
-    protected function passwordRules(): array
-    {
-        return ['required', 'string', new Password, 'confirmed'];
-    }
-}

app/Actions/Fortify/ResetUserPassword.php

@@ -5,12 +5,11 @@
 use App\Models\User;
 use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Facades\Validator;
+use Illuminate\Validation\Rules\Password;
 use Laravel\Fortify\Contracts\ResetsUserPasswords;
 
 class ResetUserPassword implements ResetsUserPasswords
 {
-    use PasswordValidationRules;
-
     /**
      * Validate and reset the user's forgotten password.
      *
@@ -19,7 +18,7 @@ class ResetUserPassword implements ResetsUserPasswords
     public function reset(User $user, array $input): void
     {
         Validator::make($input, [
-            'password' => $this->passwordRules(),
+            'password' => ['required', Password::defaults(), 'confirmed'],
         ])->validate();
 
         $user->forceFill([

app/Actions/Fortify/UpdateUserPassword.php

@@ -5,12 +5,11 @@
 use App\Models\User;
 use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Facades\Validator;
+use Illuminate\Validation\Rules\Password;
 use Laravel\Fortify\Contracts\UpdatesUserPasswords;
 
 class UpdateUserPassword implements UpdatesUserPasswords
 {
-    use PasswordValidationRules;
-
     /**
      * Validate and update the user's password.
      *
@@ -20,7 +19,7 @@ public function update(User $user, array $input): void
     {
         Validator::make($input, [
             'current_password' => ['required', 'string', 'current_password:web'],
-            'password' => $this->passwordRules(),
+            'password' => ['required', Password::defaults(), 'confirmed'],
         ], [
             'current_password.current_password' => __('The provided password does not match your current password.'),
         ])->validateWithBag('updatePassword');

app/Actions/License/CheckResaleLicense.php

@@ -1,71 +0,0 @@
-<?php
-
-namespace App\Actions\License;
-
-use Illuminate\Support\Facades\Http;
-use Lorisleiva\Actions\Concerns\AsAction;
-
-class CheckResaleLicense
-{
-    use AsAction;
-
-    public function handle()
-    {
-        try {
-            $settings = instanceSettings();
-            if (isDev()) {
-                $settings->update([
-                    'is_resale_license_active' => true,
-                ]);
-
-                return;
-            }
-            // if (!$settings->resale_license) {
-            //     return;
-            // }
-            $base_url = config('coolify.license_url');
-            $instance_id = config('app.id');
-
-            ray("Checking license key against $base_url/lemon/validate");
-            $data = Http::withHeaders([
-                'Accept' => 'application/json',
-            ])->get("$base_url/lemon/validate", [
-                'license_key' => $settings->resale_license,
-                'instance_id' => $instance_id,
-            ])->json();
-            if (data_get($data, 'valid') === true && data_get($data, 'license_key.status') === 'active') {
-                ray('Valid & active license key');
-                $settings->update([
-                    'is_resale_license_active' => true,
-                ]);
-
-                return;
-            }
-            $data = Http::withHeaders([
-                'Accept' => 'application/json',
-            ])->get("$base_url/lemon/activate", [
-                'license_key' => $settings->resale_license,
-                'instance_id' => $instance_id,
-            ])->json();
-            if (data_get($data, 'activated') === true) {
-                ray('Activated license key');
-                $settings->update([
-                    'is_resale_license_active' => true,
-                ]);
-
-                return;
-            }
-            if (data_get($data, 'license_key.status') === 'active') {
-                throw new \Exception('Invalid license key.');
-            }
-            throw new \Exception('Cannot activate license key.');
-        } catch (\Throwable $e) {
-            ray($e);
-            $settings->update([
-                'resale_license' => null,
-                'is_resale_license_active' => false,
-            ]);
-            throw $e;
-        }
-    }
-}

app/Actions/Proxy/CheckProxy.php

@@ -4,6 +4,7 @@
 
 use App\Enums\ProxyTypes;
 use App\Models\Server;
+use Illuminate\Support\Facades\Log;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -29,7 +30,7 @@ public function handle(Server $server, $fromUI = false): bool
         if (is_null($proxyType) || $proxyType === 'NONE' || $server->proxy->force_stop) {
             return false;
         }
-        ['uptime' => $uptime, 'error' => $error] = $server->validateConnection(false);
+        ['uptime' => $uptime, 'error' => $error] = $server->validateConnection();
         if (! $uptime) {
             throw new \Exception($error);
         }
@@ -88,7 +89,7 @@ public function handle(Server $server, $fromUI = false): bool
                     $portsToCheck = [];
                 }
             } catch (\Exception $e) {
-                ray($e->getMessage());
+                Log::error('Error checking proxy: '.$e->getMessage());
             }
             if (count($portsToCheck) === 0) {
                 return false;

app/Actions/Proxy/StartProxy.php

@@ -2,6 +2,7 @@
 
 namespace App\Actions\Proxy;
 
+use App\Enums\ProxyTypes;
 use App\Events\ProxyStarted;
 use App\Models\Server;
 use Lorisleiva\Actions\Concerns\AsAction;
@@ -13,67 +14,65 @@ class StartProxy
 
     public function handle(Server $server, bool $async = true, bool $force = false): string|Activity
     {
-        try {
-            $proxyType = $server->proxyType();
-            if ((is_null($proxyType) || $proxyType === 'NONE' || $server->proxy->force_stop || $server->isBuildServer()) && $force === false) {
-                return 'OK';
+        $proxyType = $server->proxyType();
+        if ((is_null($proxyType) || $proxyType === 'NONE' || $server->proxy->force_stop || $server->isBuildServer()) && $force === false) {
+            return 'OK';
+        }
+        $commands = collect([]);
+        $proxy_path = $server->proxyPath();
+        $configuration = CheckConfiguration::run($server);
+        if (! $configuration) {
+            throw new \Exception('Configuration is not synced');
+        }
+        SaveConfiguration::run($server, $configuration);
+        $docker_compose_yml_base64 = base64_encode($configuration);
+        $server->proxy->last_applied_settings = str($docker_compose_yml_base64)->pipe('md5')->value();
+        $server->save();
+        if ($server->isSwarm()) {
+            $commands = $commands->merge([
+                "mkdir -p $proxy_path/dynamic",
+                "cd $proxy_path",
+                "echo 'Creating required Docker Compose file.'",
+                "echo 'Starting coolify-proxy.'",
+                'docker stack deploy -c docker-compose.yml coolify-proxy',
+                "echo 'Successfully started coolify-proxy.'",
+            ]);
+        } else {
+            if (isDev()) {
+                if ($proxyType === ProxyTypes::CADDY->value) {
+                    $proxy_path = '/data/coolify/proxy/caddy';
+                }
             }
-            $commands = collect([]);
-            $proxy_path = $server->proxyPath();
-            $configuration = CheckConfiguration::run($server);
-            if (! $configuration) {
-                throw new \Exception('Configuration is not synced');
-            }
-            SaveConfiguration::run($server, $configuration);
-            $docker_compose_yml_base64 = base64_encode($configuration);
-            $server->proxy->last_applied_settings = str($docker_compose_yml_base64)->pipe('md5')->value();
+            $caddyfile = 'import /dynamic/*.caddy';
+            $commands = $commands->merge([
+                "mkdir -p $proxy_path/dynamic",
+                "cd $proxy_path",
+                "echo '$caddyfile' > $proxy_path/dynamic/Caddyfile",
+                "echo 'Creating required Docker Compose file.'",
+                "echo 'Pulling docker image.'",
+                'docker compose pull',
+                'if docker ps -a --format "{{.Names}}" | grep -q "^coolify-proxy$"; then',
+                "    echo 'Stopping and removing existing coolify-proxy.'",
+                '    docker rm -f coolify-proxy || true',
+                "    echo 'Successfully stopped and removed existing coolify-proxy.'",
+                'fi',
+                "echo 'Starting coolify-proxy.'",
+                'docker compose up -d --remove-orphans',
+                "echo 'Successfully started coolify-proxy.'",
+            ]);
+            $commands = $commands->merge(connectProxyToNetworks($server));
+        }
+
+        if ($async) {
+            return remote_process($commands, $server, callEventOnFinish: 'ProxyStarted', callEventData: $server);
+        } else {
+            instant_remote_process($commands, $server);
+            $server->proxy->set('status', 'running');
+            $server->proxy->set('type', $proxyType);
             $server->save();
-            if ($server->isSwarm()) {
-                $commands = $commands->merge([
-                    "mkdir -p $proxy_path/dynamic",
-                    "cd $proxy_path",
-                    "echo 'Creating required Docker Compose file.'",
-                    "echo 'Starting coolify-proxy.'",
-                    'docker stack deploy -c docker-compose.yml coolify-proxy',
-                    "echo 'Successfully started coolify-proxy.'",
-                ]);
-            } else {
-                $caddfile = 'import /dynamic/*.caddy';
-                $commands = $commands->merge([
-                    "mkdir -p $proxy_path/dynamic",
-                    "cd $proxy_path",
-                    "echo '$caddfile' > $proxy_path/dynamic/Caddyfile",
-                    "echo 'Creating required Docker Compose file.'",
-                    "echo 'Pulling docker image.'",
-                    'docker compose pull',
-                    'if docker ps -a --format "{{.Names}}" | grep -q "^coolify-proxy$"; then',
-                    "    echo 'Stopping and removing existing coolify-proxy.'",
-                    '    docker rm -f coolify-proxy || true',
-                    "    echo 'Successfully stopped and removed existing coolify-proxy.'",
-                    'fi',
-                    "echo 'Starting coolify-proxy.'",
-                    'docker compose up -d --remove-orphans',
-                    "echo 'Successfully started coolify-proxy.'",
-                ]);
-                $commands = $commands->merge(connectProxyToNetworks($server));
-            }
+            ProxyStarted::dispatch($server);
 
-            if ($async) {
-                $activity = remote_process($commands, $server, callEventOnFinish: 'ProxyStarted', callEventData: $server);
-
-                return $activity;
-            } else {
-                instant_remote_process($commands, $server);
-                $server->proxy->set('status', 'running');
-                $server->proxy->set('type', $proxyType);
-                $server->save();
-                ProxyStarted::dispatch($server);
-
-                return 'OK';
-            }
-        } catch (\Throwable $e) {
-            ray($e);
-            throw $e;
+            return 'OK';
         }
     }
 }

app/Actions/Server/CleanupDocker.php

@@ -9,11 +9,13 @@ class CleanupDocker
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public function handle(Server $server)
     {
         $settings = instanceSettings();
         $helperImageVersion = data_get($settings, 'helper_version');
-        $helperImage = config('coolify.helper_image');
+        $helperImage = config('constants.coolify.helper_image');
         $helperImageWithVersion = "$helperImage:$helperImageVersion";
 
         $commands = [

app/Actions/Server/ConfigureCloudflared.php

@@ -40,7 +40,6 @@ public function handle(Server $server, string $cloudflare_token)
             ]);
             instant_remote_process($commands, $server);
         } catch (\Throwable $e) {
-            ray($e);
             $server->settings->is_cloudflare_tunnel = false;
             $server->settings->save();
             throw $e;
@@ -51,7 +50,6 @@ public function handle(Server $server, string $cloudflare_token)
                 'rm -fr /tmp/cloudflared',
             ]);
             instant_remote_process($commands, $server);
-
         }
     }
 }

app/Actions/Server/DeleteServer.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class DeleteServer
+{
+    use AsAction;
+
+    public function handle(Server $server)
+    {
+        StopSentinel::run($server);
+        $server->forceDelete();
+    }
+}

app/Actions/Server/InstallDocker.php

@@ -12,12 +12,11 @@ class InstallDocker
 
     public function handle(Server $server)
     {
+        $dockerVersion = config('constants.docker.minimum_required_version');
         $supported_os_type = $server->validateOS();
         if (! $supported_os_type) {
             throw new \Exception('Server OS type is not supported for automated installation. Please install Docker manually before continuing: <a target="_blank" class="underline" href="https://coolify.io/docs/installation#manually">documentation</a>.');
         }
-        ray('Installing Docker on server: '.$server->name.' ('.$server->ip.')'.' with OS type: '.$supported_os_type);
-        $dockerVersion = '24.0';
         $config = base64_encode('{
             "log-driver": "json-file",
             "log-opts": {

app/Actions/Server/ResourcesCheck.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Application;
+use App\Models\ServiceApplication;
+use App\Models\ServiceDatabase;
+use App\Models\StandaloneClickhouse;
+use App\Models\StandaloneDragonfly;
+use App\Models\StandaloneKeydb;
+use App\Models\StandaloneMariadb;
+use App\Models\StandaloneMongodb;
+use App\Models\StandaloneMysql;
+use App\Models\StandalonePostgresql;
+use App\Models\StandaloneRedis;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class ResourcesCheck
+{
+    use AsAction;
+
+    public function handle()
+    {
+        $seconds = 60;
+        try {
+            Application::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            ServiceApplication::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            ServiceDatabase::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandalonePostgresql::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneRedis::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneMongodb::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneMysql::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneMariadb::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneKeydb::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneDragonfly::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneClickhouse::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+        } catch (\Throwable $e) {
+            return handleError($e);
+        }
+    }
+}

app/Actions/Server/RestartContainer.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class RestartContainer
+{
+    use AsAction;
+
+    public function handle(Server $server, string $containerName)
+    {
+        $server->restartContainer($containerName);
+    }
+}

app/Actions/Server/RunCommand.php

@@ -12,8 +12,6 @@ class RunCommand
 
     public function handle(Server $server, $command)
     {
-        $activity = remote_process(command: [$command], server: $server, ignore_errors: true, type: ActivityTypes::COMMAND->value);
-
-        return $activity;
+        return remote_process(command: [$command], server: $server, ignore_errors: true, type: ActivityTypes::COMMAND->value);
     }
 }

app/Actions/Server/ServerCheck.php

@@ -0,0 +1,267 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Actions\Database\StartDatabaseProxy;
+use App\Actions\Proxy\CheckProxy;
+use App\Actions\Proxy\StartProxy;
+use App\Jobs\CheckAndStartSentinelJob;
+use App\Jobs\ServerStorageCheckJob;
+use App\Models\Application;
+use App\Models\ApplicationPreview;
+use App\Models\Server;
+use App\Models\Service;
+use App\Models\ServiceApplication;
+use App\Models\ServiceDatabase;
+use App\Notifications\Container\ContainerRestarted;
+use Illuminate\Support\Arr;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class ServerCheck
+{
+    use AsAction;
+
+    public Server $server;
+
+    public bool $isSentinel = false;
+
+    public $containers;
+
+    public $databases;
+
+    public function handle(Server $server, $data = null)
+    {
+        $this->server = $server;
+        try {
+            if ($this->server->isFunctional() === false) {
+                return 'Server is not functional.';
+            }
+
+            if (! $this->server->isSwarmWorker() && ! $this->server->isBuildServer()) {
+
+                if (isset($data)) {
+                    $data = collect($data);
+
+                    $this->server->sentinelHeartbeat();
+
+                    $this->containers = collect(data_get($data, 'containers'));
+
+                    $filesystemUsageRoot = data_get($data, 'filesystem_usage_root.used_percentage');
+                    ServerStorageCheckJob::dispatch($this->server, $filesystemUsageRoot);
+
+                    $containerReplicates = null;
+                    $this->isSentinel = true;
+                } else {
+                    ['containers' => $this->containers, 'containerReplicates' => $containerReplicates] = $this->server->getContainers();
+                    // ServerStorageCheckJob::dispatch($this->server);
+                }
+
+                if (is_null($this->containers)) {
+                    return 'No containers found.';
+                }
+
+                if (isset($containerReplicates)) {
+                    foreach ($containerReplicates as $containerReplica) {
+                        $name = data_get($containerReplica, 'Name');
+                        $this->containers = $this->containers->map(function ($container) use ($name, $containerReplica) {
+                            if (data_get($container, 'Spec.Name') === $name) {
+                                $replicas = data_get($containerReplica, 'Replicas');
+                                $running = str($replicas)->explode('/')[0];
+                                $total = str($replicas)->explode('/')[1];
+                                if ($running === $total) {
+                                    data_set($container, 'State.Status', 'running');
+                                    data_set($container, 'State.Health.Status', 'healthy');
+                                } else {
+                                    data_set($container, 'State.Status', 'starting');
+                                    data_set($container, 'State.Health.Status', 'unhealthy');
+                                }
+                            }
+
+                            return $container;
+                        });
+                    }
+                }
+                $this->checkContainers();
+
+                if ($this->server->isSentinelEnabled() && $this->isSentinel === false) {
+                    CheckAndStartSentinelJob::dispatch($this->server);
+                }
+
+                if ($this->server->isLogDrainEnabled()) {
+                    $this->checkLogDrainContainer();
+                }
+
+                if ($this->server->proxySet() && ! $this->server->proxy->force_stop) {
+                    $foundProxyContainer = $this->containers->filter(function ($value, $key) {
+                        if ($this->server->isSwarm()) {
+                            return data_get($value, 'Spec.Name') === 'coolify-proxy_traefik';
+                        } else {
+                            return data_get($value, 'Name') === '/coolify-proxy';
+                        }
+                    })->first();
+                    if (! $foundProxyContainer) {
+                        try {
+                            $shouldStart = CheckProxy::run($this->server);
+                            if ($shouldStart) {
+                                StartProxy::run($this->server, false);
+                                $this->server->team?->notify(new ContainerRestarted('coolify-proxy', $this->server));
+                            }
+                        } catch (\Throwable $e) {
+                        }
+                    } else {
+                        $this->server->proxy->status = data_get($foundProxyContainer, 'State.Status');
+                        $this->server->save();
+                        $connectProxyToDockerNetworks = connectProxyToNetworks($this->server);
+                        instant_remote_process($connectProxyToDockerNetworks, $this->server, false);
+                    }
+                }
+            }
+        } catch (\Throwable $e) {
+            return handleError($e);
+        }
+    }
+
+    private function checkLogDrainContainer()
+    {
+        $foundLogDrainContainer = $this->containers->filter(function ($value, $key) {
+            return data_get($value, 'Name') === '/coolify-log-drain';
+        })->first();
+        if ($foundLogDrainContainer) {
+            $status = data_get($foundLogDrainContainer, 'State.Status');
+            if ($status !== 'running') {
+                StartLogDrain::dispatch($this->server);
+            }
+        } else {
+            StartLogDrain::dispatch($this->server);
+        }
+    }
+
+    private function checkContainers()
+    {
+        foreach ($this->containers as $container) {
+            if ($this->isSentinel) {
+                $labels = Arr::undot(data_get($container, 'labels'));
+            } else {
+                if ($this->server->isSwarm()) {
+                    $labels = Arr::undot(data_get($container, 'Spec.Labels'));
+                } else {
+                    $labels = Arr::undot(data_get($container, 'Config.Labels'));
+                }
+            }
+            $managed = data_get($labels, 'coolify.managed');
+            if (! $managed) {
+                continue;
+            }
+            $uuid = data_get($labels, 'coolify.name');
+            if (! $uuid) {
+                $uuid = data_get($labels, 'com.docker.compose.service');
+            }
+
+            if ($this->isSentinel) {
+                $containerStatus = data_get($container, 'state');
+                $containerHealth = data_get($container, 'health_status');
+            } else {
+                $containerStatus = data_get($container, 'State.Status');
+                $containerHealth = data_get($container, 'State.Health.Status', 'unhealthy');
+            }
+            $containerStatus = "$containerStatus ($containerHealth)";
+
+            $applicationId = data_get($labels, 'coolify.applicationId');
+            $serviceId = data_get($labels, 'coolify.serviceId');
+            $databaseId = data_get($labels, 'coolify.databaseId');
+            $pullRequestId = data_get($labels, 'coolify.pullRequestId');
+
+            if ($applicationId) {
+                // Application
+                if ($pullRequestId != 0) {
+                    if (str($applicationId)->contains('-')) {
+                        $applicationId = str($applicationId)->before('-');
+                    }
+                    $preview = ApplicationPreview::where('application_id', $applicationId)->where('pull_request_id', $pullRequestId)->first();
+                    if ($preview) {
+                        $preview->update(['status' => $containerStatus]);
+                    }
+                } else {
+                    $application = Application::where('id', $applicationId)->first();
+                    if ($application) {
+                        $application->update([
+                            'status' => $containerStatus,
+                            'last_online_at' => now(),
+                        ]);
+                    }
+                }
+            } elseif (isset($serviceId)) {
+                // Service
+                $subType = data_get($labels, 'coolify.service.subType');
+                $subId = data_get($labels, 'coolify.service.subId');
+                $service = Service::where('id', $serviceId)->first();
+                if (! $service) {
+                    continue;
+                }
+                if ($subType === 'application') {
+                    $service = ServiceApplication::where('id', $subId)->first();
+                } else {
+                    $service = ServiceDatabase::where('id', $subId)->first();
+                }
+                if ($service) {
+                    $service->update([
+                        'status' => $containerStatus,
+                        'last_online_at' => now(),
+                    ]);
+                    if ($subType === 'database') {
+                        $isPublic = data_get($service, 'is_public');
+                        if ($isPublic) {
+                            $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
+                                if ($this->isSentinel) {
+                                    return data_get($value, 'name') === $uuid.'-proxy';
+                                } else {
+
+                                    if ($this->server->isSwarm()) {
+                                        return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
+                                    } else {
+                                        return data_get($value, 'Name') === "/$uuid-proxy";
+                                    }
+                                }
+                            })->first();
+                            if (! $foundTcpProxy) {
+                                StartDatabaseProxy::run($service);
+                            }
+                        }
+                    }
+                }
+            } else {
+                // Database
+                if (is_null($this->databases)) {
+                    $this->databases = $this->server->databases();
+                }
+                $database = $this->databases->where('uuid', $uuid)->first();
+                if ($database) {
+                    $database->update([
+                        'status' => $containerStatus,
+                        'last_online_at' => now(),
+                    ]);
+
+                    $isPublic = data_get($database, 'is_public');
+                    if ($isPublic) {
+                        $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
+                            if ($this->isSentinel) {
+                                return data_get($value, 'name') === $uuid.'-proxy';
+                            } else {
+                                if ($this->server->isSwarm()) {
+                                    return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
+                                } else {
+
+                                    return data_get($value, 'Name') === "/$uuid-proxy";
+                                }
+                            }
+                        })->first();
+                        if (! $foundTcpProxy) {
+                            StartDatabaseProxy::run($database);
+                            // $this->server->team?->notify(new ContainerRestarted("TCP Proxy for database", $this->server));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

app/Actions/Server/StartLogDrain.php

@@ -5,20 +5,26 @@
 use App\Models\Server;
 use Lorisleiva\Actions\Concerns\AsAction;
 
-class InstallLogDrain
+class StartLogDrain
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public function handle(Server $server)
     {
         if ($server->settings->is_logdrain_newrelic_enabled) {
             $type = 'newrelic';
+            StopLogDrain::run($server);
         } elseif ($server->settings->is_logdrain_highlight_enabled) {
             $type = 'highlight';
+            StopLogDrain::run($server);
         } elseif ($server->settings->is_logdrain_axiom_enabled) {
             $type = 'axiom';
+            StopLogDrain::run($server);
         } elseif ($server->settings->is_logdrain_custom_enabled) {
             $type = 'custom';
+            StopLogDrain::run($server);
         } else {
             $type = 'none';
         }
@@ -151,6 +157,8 @@ public function handle(Server $server)
       - ./parsers.conf:/parsers.conf
     ports:
       - 127.0.0.1:24224:24224
+    labels:
+      - coolify.managed=true
     restart: unless-stopped
 ');
             $readme = base64_encode('# New Relic Log Drain
@@ -163,7 +171,7 @@ public function handle(Server $server)
 ');
             $license_key = $server->settings->logdrain_newrelic_license_key;
             $base_uri = $server->settings->logdrain_newrelic_base_uri;
-            $base_path = config('coolify.base_config_path');
+            $base_path = config('constants.coolify.base_config_path');
 
             $config_path = $base_path.'/log-drains';
             $fluent_bit_config = $config_path.'/fluent-bit.conf';
@@ -202,10 +210,8 @@ public function handle(Server $server)
                 throw new \Exception('Unknown log drain type.');
             }
             $restart_command = [
-                "echo 'Stopping old Fluent Bit'",
-                "cd $config_path && docker compose down --remove-orphans || true",
                 "echo 'Starting Fluent Bit'",
-                "cd $config_path && docker compose up -d --remove-orphans",
+                "cd $config_path && docker compose up -d",
             ];
             $command = array_merge($command, $add_envs_command, $restart_command);
 

app/Actions/Server/StartSentinel.php

@@ -9,18 +9,57 @@ class StartSentinel
 {
     use AsAction;
 
-    public function handle(Server $server, $version = 'latest', bool $restart = false)
+    public function handle(Server $server, bool $restart = false, ?string $latestVersion = null)
     {
+        if ($server->isSwarm() || $server->isBuildServer()) {
+            return;
+        }
         if ($restart) {
             StopSentinel::run($server);
         }
-        $metrics_history = $server->settings->metrics_history_days;
-        $refresh_rate = $server->settings->metrics_refresh_rate_seconds;
-        $token = $server->settings->metrics_token;
+        $version = $latestVersion ?? get_latest_sentinel_version();
+        $metricsHistory = data_get($server, 'settings.sentinel_metrics_history_days');
+        $refreshRate = data_get($server, 'settings.sentinel_metrics_refresh_rate_seconds');
+        $pushInterval = data_get($server, 'settings.sentinel_push_interval_seconds');
+        $token = data_get($server, 'settings.sentinel_token');
+        $endpoint = data_get($server, 'settings.sentinel_custom_url');
+        $debug = data_get($server, 'settings.is_sentinel_debug_enabled');
+        $mountDir = '/data/coolify/sentinel';
+        $image = "ghcr.io/coollabsio/sentinel:$version";
+        if (! $endpoint) {
+            throw new \Exception('You should set FQDN in Instance Settings.');
+        }
+        $environments = [
+            'TOKEN' => $token,
+            'DEBUG' => $debug ? 'true' : 'false',
+            'PUSH_ENDPOINT' => $endpoint,
+            'PUSH_INTERVAL_SECONDS' => $pushInterval,
+            'COLLECTOR_ENABLED' => $server->isMetricsEnabled() ? 'true' : 'false',
+            'COLLECTOR_REFRESH_RATE_SECONDS' => $refreshRate,
+            'COLLECTOR_RETENTION_PERIOD_DAYS' => $metricsHistory,
+        ];
+        $labels = [
+            'coolify.managed' => 'true',
+        ];
+        if (isDev()) {
+            // data_set($environments, 'DEBUG', 'true');
+            // $image = 'sentinel';
+            $mountDir = '/var/lib/docker/volumes/coolify_dev_coolify_data/_data/sentinel';
+        }
+        $dockerEnvironments = '-e "'.implode('" -e "', array_map(fn ($key, $value) => "$key=$value", array_keys($environments), $environments)).'"';
+        $dockerLabels = implode(' ', array_map(fn ($key, $value) => "$key=$value", array_keys($labels), $labels));
+        $dockerCommand = "docker run -d $dockerEnvironments --name coolify-sentinel -v /var/run/docker.sock:/var/run/docker.sock -v $mountDir:/app/db --pid host --health-cmd \"curl --fail http://127.0.0.1:8888/api/health || exit 1\" --health-interval 10s --health-retries 3 --add-host=host.docker.internal:host-gateway --label $dockerLabels $image";
+
         instant_remote_process([
-            "docker run --rm --pull always -d -e \"TOKEN={$token}\" -e \"SCHEDULER=true\" -e \"METRICS_HISTORY={$metrics_history}\" -e \"REFRESH_RATE={$refresh_rate}\" --name coolify-sentinel -v /var/run/docker.sock:/var/run/docker.sock -v /data/coolify/metrics:/app/metrics -v /data/coolify/logs:/app/logs --pid host --health-cmd \"curl --fail http://127.0.0.1:8888/api/health || exit 1\" --health-interval 10s --health-retries 3 ghcr.io/coollabsio/sentinel:$version",
-            'chown -R 9999:root /data/coolify/metrics /data/coolify/logs',
-            'chmod -R 700 /data/coolify/metrics /data/coolify/logs',
-        ], $server, true);
+            'docker rm -f coolify-sentinel || true',
+            "mkdir -p $mountDir",
+            $dockerCommand,
+            "chown -R 9999:root $mountDir",
+            "chmod -R 700 $mountDir",
+        ], $server);
+
+        $server->settings->is_sentinel_enabled = true;
+        $server->settings->save();
+        $server->sentinelHeartbeat();
     }
 }

app/Actions/Server/StopLogDrain.php

@@ -12,7 +12,7 @@ class StopLogDrain
     public function handle(Server $server)
     {
         try {
-            return instant_remote_process(['docker rm -f coolify-log-drain || true'], $server);
+            return instant_remote_process(['docker rm -f coolify-log-drain'], $server, false);
         } catch (\Throwable $e) {
             return handleError($e);
         }

app/Actions/Server/StopSentinel.php

@@ -12,5 +12,6 @@ class StopSentinel
     public function handle(Server $server)
     {
         instant_remote_process(['docker rm -f coolify-sentinel'], $server, false);
+        $server->sentinelHeartbeat(isReset: true);
     }
 }

app/Actions/Server/UpdateCoolify.php

@@ -4,6 +4,7 @@
 
 use App\Jobs\PullHelperImageJob;
 use App\Models\Server;
+use Illuminate\Support\Sleep;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class UpdateCoolify
@@ -18,49 +19,38 @@ class UpdateCoolify
 
     public function handle($manual_update = false)
     {
-        try {
-            $settings = instanceSettings();
-            $this->server = Server::find(0);
-            if (! $this->server) {
+        if (isDev()) {
+            Sleep::for(10)->seconds();
+
+            return;
+        }
+        $settings = instanceSettings();
+        $this->server = Server::find(0);
+        if (! $this->server) {
+            return;
+        }
+        CleanupDocker::dispatch($this->server);
+        $this->latestVersion = get_latest_version_of_coolify();
+        $this->currentVersion = config('constants.coolify.version');
+        if (! $manual_update) {
+            if (! $settings->is_auto_update_enabled) {
                 return;
             }
-            CleanupDocker::dispatch($this->server)->onQueue('high');
-            $this->latestVersion = get_latest_version_of_coolify();
-            $this->currentVersion = config('version');
-            if (! $manual_update) {
-                if (! $settings->is_auto_update_enabled) {
-                    return;
-                }
-                if ($this->latestVersion === $this->currentVersion) {
-                    return;
-                }
-                if (version_compare($this->latestVersion, $this->currentVersion, '<')) {
-                    return;
-                }
+            if ($this->latestVersion === $this->currentVersion) {
+                return;
+            }
+            if (version_compare($this->latestVersion, $this->currentVersion, '<')) {
+                return;
             }
-            $this->update();
-            $settings->new_version_available = false;
-            $settings->save();
-        } catch (\Throwable $e) {
-            throw $e;
         }
+        $this->update();
+        $settings->new_version_available = false;
+        $settings->save();
     }
 
     private function update()
     {
-        if (isDev()) {
-            remote_process([
-                'sleep 10',
-            ], $this->server);
-
-            return;
-        }
-
-        $all_servers = Server::all();
-        $servers = $all_servers->where('settings.is_usable', true)->where('settings.is_reachable', true)->where('ip', '!=', '1.2.3.4');
-        foreach ($servers as $server) {
-            PullHelperImageJob::dispatch($server);
-        }
+        PullHelperImageJob::dispatch($this->server);
 
         instant_remote_process(["docker pull -q ghcr.io/coollabsio/coolify:{$this->latestVersion}"], $this->server, false);
 

app/Actions/Server/ValidateServer.php

@@ -9,6 +9,8 @@ class ValidateServer
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public ?string $uptime = null;
 
     public ?string $error = null;

app/Actions/Service/DeleteService.php

@@ -4,6 +4,7 @@
 
 use App\Actions\Server\CleanupDocker;
 use App\Models\Service;
+use Illuminate\Support\Facades\Log;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class DeleteService
@@ -39,8 +40,8 @@ public function handle(Service $service, bool $deleteConfigurations, bool $delet
                 if (! empty($commands)) {
                     foreach ($commands as $command) {
                         $result = instant_remote_process([$command], $server, false);
-                        if ($result !== 0) {
-                            ray("Failed to execute: $command");
+                        if ($result !== null && $result !== 0) {
+                            Log::error('Error deleting volumes: '.$result);
                         }
                     }
                 }

app/Actions/Service/RestartService.php

@@ -9,6 +9,8 @@ class RestartService
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public function handle(Service $service)
     {
         StopService::run($service);

app/Actions/Service/StartService.php

@@ -10,9 +10,10 @@ class StartService
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public function handle(Service $service)
     {
-        ray('Starting service: '.$service->name);
         $service->saveComposeConfigs();
         $commands[] = 'cd '.$service->workdir();
         $commands[] = "echo 'Saved configuration files to {$service->workdir()}.'";
@@ -34,8 +35,7 @@ public function handle(Service $service)
                 $commands[] = "docker network connect --alias {$serviceName}-{$service->uuid} $network {$serviceName}-{$service->uuid} >/dev/null 2>&1 || true";
             }
         }
-        $activity = remote_process($commands, $service->server, type_uuid: $service->uuid, callEventOnFinish: 'ServiceStatusChanged');
 
-        return $activity;
+        return remote_process($commands, $service->server, type_uuid: $service->uuid, callEventOnFinish: 'ServiceStatusChanged');
     }
 }

app/Actions/Service/StopService.php

@@ -10,6 +10,8 @@ class StopService
 {
     use AsAction;
 
+    public string $jobQueue = 'high';
+
     public function handle(Service $service, bool $isDeleteOperation = false, bool $dockerCleanup = true)
     {
         try {
@@ -28,8 +30,6 @@ public function handle(Service $service, bool $isDeleteOperation = false, bool $
                 }
             }
         } catch (\Exception $e) {
-            ray($e->getMessage());
-
             return $e->getMessage();
         }
     }

app/Console/Commands/CleanupDatabase.php

@@ -7,7 +7,7 @@
 
 class CleanupDatabase extends Command
 {
-    protected $signature = 'cleanup:database {--yes}';
+    protected $signature = 'cleanup:database {--yes} {--keep-days=}';
 
     protected $description = 'Cleanup database';
 
@@ -20,9 +20,9 @@ public function handle()
         }
         if (isCloud()) {
             // Later on we can increase this to 180 days or dynamically set
-            $keep_days = 60;
+            $keep_days = $this->option('keep-days') ?? 60;
         } else {
-            $keep_days = 60;
+            $keep_days = $this->option('keep-days') ?? 60;
         }
         echo "Keep days: $keep_days\n";
         // Cleanup failed jobs table
@@ -64,6 +64,5 @@ public function handle()
         if ($this->option('yes')) {
             $webhooks->delete();
         }
-
     }
 }

app/Console/Commands/CleanupRedis.php

@@ -13,7 +13,6 @@ class CleanupRedis extends Command
 
     public function handle()
     {
-        echo "Cleanup Redis keys.\n";
         $prefix = config('database.redis.options.prefix');
 
         $keys = Redis::connection()->keys('*:laravel*');
@@ -26,6 +25,5 @@ public function handle()
         collect($queueOverlaps)->each(function ($key) {
             Redis::connection()->del($key);
         });
-
     }
 }

app/Console/Commands/CleanupStuckedResources.php

@@ -30,14 +30,11 @@ class CleanupStuckedResources extends Command
 
     public function handle()
     {
-        ray('Running cleanup stucked resources.');
-        echo "Running cleanup stucked resources.\n";
         $this->cleanup_stucked_resources();
     }
 
     private function cleanup_stucked_resources()
     {
-
         try {
             $servers = Server::all()->filter(function ($server) {
                 return $server->isFunctional();

app/Console/Commands/CleanupUnreachableServers.php

@@ -18,7 +18,6 @@ public function handle()
         if ($servers->count() > 0) {
             foreach ($servers as $server) {
                 echo "Cleanup unreachable server ($server->id) with name $server->name";
-                // send_internal_notification("Server $server->name is unreachable for 7 days. Cleaning up...");
                 $server->update([
                     'ip' => '1.2.3.4',
                 ]);

app/Console/Commands/CloudCheckSubscription.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Team;
+use Illuminate\Console\Command;
+
+class CloudCheckSubscription extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'cloud:check-subscription';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Check Cloud subscriptions';
+
+    /**
+     * Execute the console command.
+     */
+    public function handle()
+    {
+        $stripe = new \Stripe\StripeClient(config('subscription.stripe_api_key'));
+        $activeSubscribers = Team::whereRelation('subscription', 'stripe_invoice_paid', true)->get();
+        foreach ($activeSubscribers as $team) {
+            $stripeSubscriptionId = $team->subscription->stripe_subscription_id;
+            $stripeInvoicePaid = $team->subscription->stripe_invoice_paid;
+            $stripeCustomerId = $team->subscription->stripe_customer_id;
+            if (! $stripeSubscriptionId) {
+                echo "Team {$team->id} has no subscription, but invoice status is: {$stripeInvoicePaid}\n";
+                echo "Link on Stripe: https://dashboard.stripe.com/customers/{$stripeCustomerId}\n";
+
+                continue;
+            }
+            $subscription = $stripe->subscriptions->retrieve($stripeSubscriptionId);
+            if ($subscription->status === 'active') {
+                continue;
+            }
+            echo "Subscription {$stripeSubscriptionId} is not active ({$subscription->status})\n";
+            echo "Link on Stripe: https://dashboard.stripe.com/subscriptions/{$stripeSubscriptionId}\n";
+        }
+    }
+}

app/Console/Commands/CloudCleanupSubscriptions.php

@@ -19,7 +19,6 @@ public function handle()
 
                 return;
             }
-            ray()->clearAll();
             $this->info('Cleaning up subcriptions teams');
             $stripe = new \Stripe\StripeClient(config('subscription.stripe_api_key'));
 
@@ -37,7 +36,7 @@ public function handle()
                 }
                 // If the team has no subscription id and the invoice is paid, we need to reset the invoice paid status
                 if (! (data_get($team, 'subscription.stripe_subscription_id'))) {
-                    $this->info("Resetting invoice paid status for team {$team->id} {$team->name}");
+                    $this->info("Resetting invoice paid status for team {$team->id}");
 
                     $team->subscription->update([
                         'stripe_invoice_paid' => false,
@@ -62,9 +61,9 @@ public function handle()
                     $this->info('Subscription id: '.data_get($team, 'subscription.stripe_subscription_id'));
                     $confirm = $this->confirm('Do you want to cancel the subscription?', true);
                     if (! $confirm) {
-                        $this->info("Skipping team {$team->id} {$team->name}");
+                        $this->info("Skipping team {$team->id}");
                     } else {
-                        $this->info("Cancelling subscription for team {$team->id} {$team->name}");
+                        $this->info("Cancelling subscription for team {$team->id}");
                         $team->subscription->update([
                             'stripe_invoice_paid' => false,
                             'stripe_trial_already_ended' => false,
@@ -74,7 +73,6 @@ public function handle()
                     }
                 }
             }
-
         } catch (\Exception $e) {
             $this->error($e->getMessage());
 
@@ -96,6 +94,5 @@ private function disableServers(Team $team)
                 ]);
             }
         }
-
     }
 }

app/Console/Commands/Dev.php

@@ -6,6 +6,7 @@
 use Illuminate\Console\Command;
 use Illuminate\Support\Facades\Artisan;
 use Illuminate\Support\Facades\Process;
+use Symfony\Component\Yaml\Yaml;
 
 class Dev extends Command
 {
@@ -25,26 +26,38 @@ public function handle()
 
             return;
         }
-
     }
 
     public function generateOpenApi()
     {
         // Generate OpenAPI documentation
         echo "Generating OpenAPI documentation.\n";
-        $process = Process::run(['/var/www/html/vendor/bin/openapi', 'app', '-o', 'openapi.yaml']);
+        // https://github.com/OAI/OpenAPI-Specification/releases
+        $process = Process::run([
+            '/var/www/html/vendor/bin/openapi',
+            'app',
+            '-o',
+            'openapi.yaml',
+            '--version',
+            '3.1.0',
+        ]);
         $error = $process->errorOutput();
         $error = preg_replace('/^.*an object literal,.*$/m', '', $error);
         $error = preg_replace('/^\h*\v+/m', '', $error);
         echo $error;
         echo $process->output();
+        // Convert YAML to JSON
+        $yaml = file_get_contents('openapi.yaml');
+        $json = json_encode(Yaml::parse($yaml), JSON_PRETTY_PRINT);
+        file_put_contents('openapi.json', $json);
+        echo "Converted OpenAPI YAML to JSON.\n";
     }
 
     public function init()
     {
         // Generate APP_KEY if not exists
 
-        if (empty(env('APP_KEY'))) {
+        if (empty(config('app.key'))) {
             echo "Generating APP_KEY.\n";
             Artisan::call('key:generate');
         }
@@ -63,7 +76,5 @@ public function init()
         } else {
             echo "Instance already initialized.\n";
         }
-        // Set permissions
-        Process::run(['chmod', '-R', 'o+rwx', '.']);
     }
 }

app/Console/Commands/Emails.php

@@ -2,20 +2,17 @@
 
 namespace App\Console\Commands;
 
-use App\Jobs\SendConfirmationForWaitlistJob;
 use App\Models\Application;
 use App\Models\ApplicationPreview;
 use App\Models\ScheduledDatabaseBackup;
 use App\Models\Server;
 use App\Models\StandalonePostgresql;
 use App\Models\Team;
-use App\Models\Waitlist;
 use App\Notifications\Application\DeploymentFailed;
 use App\Notifications\Application\DeploymentSuccess;
 use App\Notifications\Application\StatusChanged;
 use App\Notifications\Database\BackupFailed;
 use App\Notifications\Database\BackupSuccess;
-use App\Notifications\Database\DailyBackup;
 use App\Notifications\Test;
 use Exception;
 use Illuminate\Console\Command;
@@ -65,8 +62,6 @@ public function handle()
                 'backup-success' => 'Database - Backup Success',
                 'backup-failed' => 'Database - Backup Failed',
                 // 'invitation-link' => 'Invitation Link',
-                'waitlist-invitation-link' => 'Waitlist Invitation Link',
-                'waitlist-confirmation' => 'Waitlist Confirmation',
                 'realusers-before-trial' => 'REAL - Registered Users Before Trial without Subscription',
                 'realusers-server-lost-connection' => 'REAL - Server Lost Connection',
             ],
@@ -121,28 +116,10 @@ public function handle()
                 $this->mail = (new Test)->toMail();
                 $this->sendEmail();
                 break;
-            case 'database-backup-statuses-daily':
-                $scheduled_backups = ScheduledDatabaseBackup::all();
-                $databases = collect();
-                foreach ($scheduled_backups as $scheduled_backup) {
-                    $last_days_backups = $scheduled_backup->get_last_days_backup_status();
-                    if ($last_days_backups->isEmpty()) {
-                        continue;
-                    }
-                    $failed = $last_days_backups->where('status', 'failed');
-                    $database = $scheduled_backup->database;
-                    $databases->put($database->name, [
-                        'failed_count' => $failed->count(),
-                    ]);
-                }
-                $this->mail = (new DailyBackup($databases))->toMail();
-                $this->sendEmail();
-                break;
             case 'application-deployment-success-daily':
                 $applications = Application::all();
                 foreach ($applications as $application) {
                     $deployments = $application->get_last_days_deployments();
-                    ray($deployments);
                     if ($deployments->isEmpty()) {
                         continue;
                     }
@@ -206,7 +183,7 @@ public function handle()
                         'team_id' => 0,
                     ]);
                 }
-                $this->mail = (new BackupSuccess($backup, $db))->toMail();
+                //$this->mail = (new BackupSuccess($backup->frequency, $db->name))->toMail();
                 $this->sendEmail();
                 break;
                 // case 'invitation-link':
@@ -223,23 +200,6 @@ public function handle()
                 //     $this->mail = (new InvitationLink($user))->toMail();
                 //     $this->sendEmail();
                 //     break;
-            case 'waitlist-invitation-link':
-                $this->mail = new MailMessage;
-                $this->mail->view('emails.waitlist-invitation', [
-                    'loginLink' => 'https://coolify.io',
-                ]);
-                $this->mail->subject('Congratulations! You are invited to join Coolify Cloud.');
-                $this->sendEmail();
-                break;
-            case 'waitlist-confirmation':
-                $found = Waitlist::where('email', $this->email)->first();
-                if ($found) {
-                    SendConfirmationForWaitlistJob::dispatch($this->email, $found->uuid);
-                } else {
-                    throw new Exception('Waitlist not found');
-                }
-
-                break;
             case 'realusers-before-trial':
                 $this->mail = new MailMessage;
                 $this->mail->view('emails.before-trial-conversion');

app/Console/Commands/Horizon.php

@@ -12,8 +12,8 @@ class Horizon extends Command
 
     public function handle()
     {
-        if (config('coolify.is_horizon_enabled')) {
-            $this->info('Horizon is enabled. Starting.');
+        if (config('constants.horizon.is_horizon_enabled')) {
+            $this->info('Horizon is enabled on this server.');
             $this->call('horizon');
             exit(0);
         } else {

app/Console/Commands/Init.php

@@ -2,15 +2,17 @@
 
 namespace App\Console\Commands;
 
-use App\Actions\Server\StopSentinel;
 use App\Enums\ActivityTypes;
 use App\Enums\ApplicationDeploymentStatus;
+use App\Jobs\CheckHelperImageJob;
 use App\Models\ApplicationDeploymentQueue;
 use App\Models\Environment;
 use App\Models\ScheduledDatabaseBackup;
 use App\Models\Server;
 use App\Models\StandalonePostgresql;
+use App\Models\User;
 use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Artisan;
 use Illuminate\Support\Facades\File;
 use Illuminate\Support\Facades\Http;
 
@@ -24,6 +26,8 @@ class Init extends Command
 
     public function handle()
     {
+        $this->optimize();
+
         if (isCloud() && ! $this->option('force-cloud')) {
             echo "Skipping init as we are on cloud and --force-cloud option is not set\n";
 
@@ -32,16 +36,15 @@ public function handle()
 
         $this->servers = Server::all();
         if (isCloud()) {
-
         } else {
             $this->send_alive_signal();
             get_public_ips();
         }
 
         // Backward compatibility
-        $this->disable_metrics();
         $this->replace_slash_in_environment_name();
         $this->restore_coolify_db_backup();
+        $this->update_user_emails();
         //
         $this->update_traefik_labels();
         if (! isCloud() || $this->option('force-cloud')) {
@@ -53,15 +56,29 @@ public function handle()
             $this->cleanup_in_progress_application_deployments();
         }
         $this->call('cleanup:redis');
+
         $this->call('cleanup:stucked-resources');
 
+        try {
+            $this->pullHelperImage();
+        } catch (\Throwable $e) {
+            //
+        }
+
         if (isCloud()) {
-            $response = Http::retry(3, 1000)->get(config('constants.services.official'));
-            if ($response->successful()) {
-                $services = $response->json();
-                File::put(base_path('templates/service-templates.json'), json_encode($services));
+            try {
+                $this->pullTemplatesFromCDN();
+            } catch (\Throwable $e) {
+                echo "Could not pull templates from CDN: {$e->getMessage()}\n";
+            }
+        }
+
+        if (! isCloud()) {
+            try {
+                $this->pullTemplatesFromCDN();
+            } catch (\Throwable $e) {
+                echo "Could not pull templates from CDN: {$e->getMessage()}\n";
             }
-        } else {
             try {
                 $localhost = $this->servers->where('id', 0)->first();
                 $localhost->setupDynamicProxyConfiguration();
@@ -69,8 +86,8 @@ public function handle()
                 echo "Could not setup dynamic configuration: {$e->getMessage()}\n";
             }
             $settings = instanceSettings();
-            if (! is_null(env('AUTOUPDATE', null))) {
-                if (env('AUTOUPDATE') == true) {
+            if (! is_null(config('constants.coolify.autoupdate', null))) {
+                if (config('constants.coolify.autoupdate') == true) {
                     $settings->update(['is_auto_update_enabled' => true]);
                 } else {
                     $settings->update(['is_auto_update_enabled' => false]);
@@ -79,17 +96,32 @@ public function handle()
         }
     }
 
-    private function disable_metrics()
+    private function pullHelperImage()
     {
-        if (version_compare('4.0.0-beta.312', config('version'), '<=')) {
-            foreach ($this->servers as $server) {
-                if ($server->settings->is_metrics_enabled === true) {
-                    $server->settings->update(['is_metrics_enabled' => false]);
-                }
-                if ($server->isFunctional()) {
-                    StopSentinel::dispatch($server);
-                }
-            }
+        CheckHelperImageJob::dispatch();
+    }
+
+    private function pullTemplatesFromCDN()
+    {
+        $response = Http::retry(3, 1000)->get(config('constants.services.official'));
+        if ($response->successful()) {
+            $services = $response->json();
+            File::put(base_path('templates/service-templates.json'), json_encode($services));
+        }
+    }
+
+    private function optimize()
+    {
+        Artisan::call('optimize:clear');
+        Artisan::call('optimize');
+    }
+
+    private function update_user_emails()
+    {
+        try {
+            User::whereRaw('email ~ \'[A-Z]\'')->get()->each(fn (User $user) => $user->update(['email' => strtolower($user->email)]));
+        } catch (\Throwable $e) {
+            echo "Error in updating user emails: {$e->getMessage()}\n";
         }
     }
 
@@ -120,7 +152,6 @@ private function cleanup_unnecessary_dynamic_proxy_configuration()
             } catch (\Throwable $e) {
                 echo "Error in cleaning up unnecessary dynamic proxy configuration: {$e->getMessage()}\n";
             }
-
         }
     }
 
@@ -155,7 +186,6 @@ private function cleanup_unused_network_from_coolify_proxy()
                     }
                 }
                 if ($commands->isNotEmpty()) {
-                    echo "Cleaning up unused networks from coolify proxy\n";
                     remote_process(command: $commands, type: ActivityTypes::INLINE->value, server: $server, ignore_errors: false);
                 }
             } catch (\Throwable $e) {
@@ -166,7 +196,7 @@ private function cleanup_unused_network_from_coolify_proxy()
 
     private function restore_coolify_db_backup()
     {
-        if (version_compare('4.0.0-beta.179', config('version'), '<=')) {
+        if (version_compare('4.0.0-beta.179', config('constants.coolify.version'), '<=')) {
             try {
                 $database = StandalonePostgresql::withTrashed()->find(0);
                 if ($database && $database->trashed()) {
@@ -180,7 +210,7 @@ private function restore_coolify_db_backup()
                             'save_s3' => false,
                             'frequency' => '0 0 * * *',
                             'database_id' => $database->id,
-                            'database_type' => 'App\Models\StandalonePostgresql',
+                            'database_type' => \App\Models\StandalonePostgresql::class,
                             'team_id' => 0,
                         ]);
                     }
@@ -194,19 +224,18 @@ private function restore_coolify_db_backup()
     private function send_alive_signal()
     {
         $id = config('app.id');
-        $version = config('version');
+        $version = config('constants.coolify.version');
         $settings = instanceSettings();
         $do_not_track = data_get($settings, 'do_not_track');
         if ($do_not_track == true) {
-            echo "Skipping alive as do_not_track is enabled\n";
+            echo "Do_not_track is enabled\n";
 
             return;
         }
         try {
             Http::get("https://undead.coolify.io/v4/alive?appId=$id&version=$version");
-            echo "I am alive!\n";
         } catch (\Throwable $e) {
-            echo "Error in alive: {$e->getMessage()}\n";
+            echo "Error in sending live signal: {$e->getMessage()}\n";
         }
     }
 
@@ -219,8 +248,6 @@ private function cleanup_in_progress_application_deployments()
             }
             $queued_inprogress_deployments = ApplicationDeploymentQueue::whereIn('status', [ApplicationDeploymentStatus::IN_PROGRESS->value, ApplicationDeploymentStatus::QUEUED->value])->get();
             foreach ($queued_inprogress_deployments as $deployment) {
-                ray($deployment->id, $deployment->status);
-                echo "Cleaning up deployment: {$deployment->id}\n";
                 $deployment->status = ApplicationDeploymentStatus::FAILED->value;
                 $deployment->save();
             }
@@ -231,7 +258,7 @@ private function cleanup_in_progress_application_deployments()
 
     private function replace_slash_in_environment_name()
     {
-        if (version_compare('4.0.0-beta.298', config('version'), '<=')) {
+        if (version_compare('4.0.0-beta.298', config('constants.coolify.version'), '<=')) {
             $environments = Environment::all();
             foreach ($environments as $environment) {
                 if (str_contains($environment->name, '/')) {

app/Console/Commands/NotifyDemo.php

@@ -36,8 +36,6 @@ public function handle()
 
             return;
         }
-
-        ray($channel);
     }
 
     private function showHelp()

app/Console/Commands/OpenApi.php

@@ -15,12 +15,19 @@ public function handle()
     {
         // Generate OpenAPI documentation
         echo "Generating OpenAPI documentation.\n";
-        $process = Process::run(['/var/www/html/vendor/bin/openapi', 'app', '-o', 'openapi.yaml']);
+        // https://github.com/OAI/OpenAPI-Specification/releases
+        $process = Process::run([
+            '/var/www/html/vendor/bin/openapi',
+            'app',
+            '-o',
+            'openapi.yaml',
+            '--version',
+            '3.1.0',
+        ]);
         $error = $process->errorOutput();
         $error = preg_replace('/^.*an object literal,.*$/m', '', $error);
         $error = preg_replace('/^\h*\v+/m', '', $error);
         echo $error;
         echo $process->output();
-
     }
 }

app/Console/Commands/Scheduler.php

@@ -12,8 +12,8 @@ class Scheduler extends Command
 
     public function handle()
     {
-        if (config('coolify.is_scheduler_enabled')) {
-            $this->info('Scheduler is enabled. Starting.');
+        if (config('constants.horizon.is_scheduler_enabled')) {
+            $this->info('Scheduler is enabled on this server.');
             $this->call('schedule:work');
             exit(0);
         } else {

app/Console/Commands/ServicesGenerate.php

@@ -3,128 +3,85 @@
 namespace App\Console\Commands;
 
 use Illuminate\Console\Command;
+use Illuminate\Support\Arr;
 use Symfony\Component\Yaml\Yaml;
 
 class ServicesGenerate extends Command
 {
     /**
-     * The name and signature of the console command.
-     *
-     * @var string
+     * {@inheritdoc}
      */
     protected $signature = 'services:generate';
 
     /**
-     * The console command description.
-     *
-     * @var string
+     * {@inheritdoc}
      */
     protected $description = 'Generate service-templates.yaml based on /templates/compose directory';
 
-    /**
-     * Execute the console command.
-     */
-    public function handle()
+    public function handle(): int
     {
-        $files = array_diff(scandir(base_path('templates/compose')), ['.', '..']);
-        $files = array_filter($files, function ($file) {
-            return strpos($file, '.yaml') !== false;
-        });
-        $serviceTemplatesJson = [];
-        foreach ($files as $file) {
-            $parsed = $this->process_file($file);
-            if ($parsed) {
-                $name = data_get($parsed, 'name');
-                $parsed = data_forget($parsed, 'name');
-                $serviceTemplatesJson[$name] = $parsed;
-            }
-        }
-        $serviceTemplatesJson = json_encode($serviceTemplatesJson, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
+        $serviceTemplatesJson = collect(array_merge(
+            glob(base_path('templates/compose/*.yaml')),
+            glob(base_path('templates/compose/*.yml'))
+        ))
+            ->mapWithKeys(function ($file): array {
+                $file = basename($file);
+                $parsed = $this->processFile($file);
+
+                return $parsed === false ? [] : [
+                    Arr::pull($parsed, 'name') => $parsed,
+                ];
+            })->toJson(JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
+
         file_put_contents(base_path('templates/service-templates.json'), $serviceTemplatesJson.PHP_EOL);
+
+        return self::SUCCESS;
     }
 
-    private function process_file($file)
+    private function processFile(string $file): false|array
     {
-        $serviceName = str($file)->before('.yaml')->value();
         $content = file_get_contents(base_path("templates/compose/$file"));
-        // $this->info($content);
-        $ignore = collect(preg_grep('/^# ignore:/', explode("\n", $content)))->values();
-        if ($ignore->count() > 0) {
-            $ignore = (bool) str($ignore[0])->after('# ignore:')->trim()->value();
-        } else {
-            $ignore = false;
-        }
-        if ($ignore) {
+
+        $data = collect(explode(PHP_EOL, $content))->mapWithKeys(function ($line): array {
+            preg_match('/^#(?<key>.*):(?<value>.*)$/U', $line, $m);
+
+            return $m ? [trim($m['key']) => trim($m['value'])] : [];
+        });
+
+        if (str($data->get('ignore'))->toBoolean()) {
             $this->info("Ignoring $file");
 
-            return;
+            return false;
         }
+
         $this->info("Processing $file");
-        $documentation = collect(preg_grep('/^# documentation:/', explode("\n", $content)))->values();
-        if ($documentation->count() > 0) {
-            $documentation = str($documentation[0])->after('# documentation:')->trim()->value();
-            $documentation = str($documentation)->append('?utm_source=coolify.io');
-        } else {
-            $documentation = 'https://coolify.io/docs';
-        }
 
-        $slogan = collect(preg_grep('/^# slogan:/', explode("\n", $content)))->values();
-        if ($slogan->count() > 0) {
-            $slogan = str($slogan[0])->after('# slogan:')->trim()->value();
-        } else {
-            $slogan = str($file)->headline()->value();
-        }
-        $logo = collect(preg_grep('/^# logo:/', explode("\n", $content)))->values();
-        if ($logo->count() > 0) {
-            $logo = str($logo[0])->after('# logo:')->trim()->value();
-        } else {
-            $logo = 'svgs/coolify.png';
-        }
-        $minversion = collect(preg_grep('/^# minversion:/', explode("\n", $content)))->values();
-        if ($minversion->count() > 0) {
-            $minversion = str($minversion[0])->after('# minversion:')->trim()->value();
-        } else {
-            $minversion = '0.0.0';
-        }
-        $env_file = collect(preg_grep('/^# env_file:/', explode("\n", $content)))->values();
-        if ($env_file->count() > 0) {
-            $env_file = str($env_file[0])->after('# env_file:')->trim()->value();
-        } else {
-            $env_file = null;
-        }
+        $documentation = $data->get('documentation');
+        $documentation = $documentation ? $documentation.'?utm_source=coolify.io' : 'https://coolify.io/docs';
 
-        $tags = collect(preg_grep('/^# tags:/', explode("\n", $content)))->values();
-        if ($tags->count() > 0) {
-            $tags = str($tags[0])->after('# tags:')->trim()->explode(',')->map(function ($tag) {
-                return str($tag)->trim()->lower()->value();
-            })->values();
-        } else {
-            $tags = null;
-        }
-        $port = collect(preg_grep('/^# port:/', explode("\n", $content)))->values();
-        if ($port->count() > 0) {
-            $port = str($port[0])->after('# port:')->trim()->value();
-        } else {
-            $port = null;
-        }
         $json = Yaml::parse($content);
-        $yaml = base64_encode(Yaml::dump($json, 10, 2));
+        $compose = base64_encode(Yaml::dump($json, 10, 2));
+
+        $tags = str($data->get('tags'))->lower()->explode(',')->map(fn ($tag) => trim($tag))->filter();
+        $tags = $tags->isEmpty() ? null : $tags->all();
+
         $payload = [
-            'name' => $serviceName,
+            'name' => pathinfo($file, PATHINFO_FILENAME),
             'documentation' => $documentation,
-            'slogan' => $slogan,
-            'compose' => $yaml,
+            'slogan' => $data->get('slogan', str($file)->headline()),
+            'compose' => $compose,
             'tags' => $tags,
-            'logo' => $logo,
-            'minversion' => $minversion,
+            'logo' => $data->get('logo', 'svgs/default.webp'),
+            'minversion' => $data->get('minversion', '0.0.0'),
         ];
-        if ($port) {
+
+        if ($port = $data->get('port')) {
             $payload['port'] = $port;
         }
-        if ($env_file) {
-            $env_file_content = file_get_contents(base_path("templates/compose/$env_file"));
-            $env_file_base64 = base64_encode($env_file_content);
-            $payload['envs'] = $env_file_base64;
+
+        if ($envFile = $data->get('env_file')) {
+            $envFileContent = file_get_contents(base_path("templates/compose/$envFile"));
+            $payload['envs'] = base64_encode($envFileContent);
         }
 
         return $payload;

app/Console/Commands/SyncBunny.php

@@ -57,7 +57,7 @@ public function handle()
 
         PendingRequest::macro('storage', function ($fileName) use ($that) {
             $headers = [
-                'AccessKey' => env('BUNNY_STORAGE_API_KEY'),
+                'AccessKey' => config('constants.bunny.storage_api_key'),
                 'Accept' => 'application/json',
                 'Content-Type' => 'application/octet-stream',
             ];
@@ -69,7 +69,7 @@ public function handle()
         });
         PendingRequest::macro('purge', function ($url) use ($that) {
             $headers = [
-                'AccessKey' => env('BUNNY_API_KEY'),
+                'AccessKey' => config('constants.bunny.api_key'),
                 'Accept' => 'application/json',
             ];
             $that->info('Purging: '.$url);

app/Console/Commands/WaitlistInvite.php

@@ -1,114 +0,0 @@
-<?php
-
-namespace App\Console\Commands;
-
-use App\Models\User;
-use App\Models\Waitlist;
-use Illuminate\Console\Command;
-use Illuminate\Notifications\Messages\MailMessage;
-use Illuminate\Support\Facades\Crypt;
-use Illuminate\Support\Facades\Hash;
-use Illuminate\Support\Str;
-
-class WaitlistInvite extends Command
-{
-    public Waitlist|User|null $next_patient = null;
-
-    public ?string $password = null;
-
-    /**
-     * The name and signature of the console command.
-     *
-     * @var string
-     */
-    protected $signature = 'waitlist:invite {--people=1} {--only-email} {email?}';
-
-    /**
-     * The console command description.
-     *
-     * @var string
-     */
-    protected $description = 'Send invitation to the next user (or by email) in the waitlist';
-
-    /**
-     * Execute the console command.
-     */
-    public function handle()
-    {
-        $people = $this->option('people');
-        for ($i = 0; $i < $people; $i++) {
-            $this->main();
-        }
-    }
-
-    private function main()
-    {
-        if ($this->argument('email')) {
-            if ($this->option('only-email')) {
-                $this->next_patient = User::whereEmail($this->argument('email'))->first();
-                $this->password = Str::password();
-                $this->next_patient->update([
-                    'password' => Hash::make($this->password),
-                    'force_password_reset' => true,
-                ]);
-            } else {
-                $this->next_patient = Waitlist::where('email', $this->argument('email'))->first();
-            }
-            if (! $this->next_patient) {
-                $this->error("{$this->argument('email')} not found in the waitlist.");
-
-                return;
-            }
-        } else {
-            $this->next_patient = Waitlist::orderBy('created_at', 'asc')->where('verified', true)->first();
-        }
-        if ($this->next_patient) {
-            if ($this->option('only-email')) {
-                $this->send_email();
-
-                return;
-            }
-            $this->register_user();
-            $this->remove_from_waitlist();
-            $this->send_email();
-        } else {
-            $this->info('No verified user found in the waitlist. 👀');
-        }
-    }
-
-    private function register_user()
-    {
-        $already_registered = User::whereEmail($this->next_patient->email)->first();
-        if (! $already_registered) {
-            $this->password = Str::password();
-            User::create([
-                'name' => str($this->next_patient->email)->before('@'),
-                'email' => $this->next_patient->email,
-                'password' => Hash::make($this->password),
-                'force_password_reset' => true,
-            ]);
-            $this->info("User registered ({$this->next_patient->email}) successfully. 🎉");
-        } else {
-            throw new \Exception('User already registered');
-        }
-    }
-
-    private function remove_from_waitlist()
-    {
-        $this->next_patient->delete();
-        $this->info('User removed from waitlist successfully.');
-    }
-
-    private function send_email()
-    {
-        $token = Crypt::encryptString("{$this->next_patient->email}@@@$this->password");
-        $loginLink = route('auth.link', ['token' => $token]);
-        $mail = new MailMessage;
-        $mail->view('emails.waitlist-invitation', [
-            'loginLink' => $loginLink,
-        ]);
-        $mail->subject('Congratulations! You are invited to join Coolify Cloud.');
-        send_user_an_email($mail, $this->next_patient->email);
-        $this->info('Email sent successfully. 📧');
-    }
-}

app/Console/Kernel.php

@@ -2,142 +2,181 @@
 
 namespace App\Console;
 
+use App\Jobs\CheckAndStartSentinelJob;
 use App\Jobs\CheckForUpdatesJob;
+use App\Jobs\CheckHelperImageJob;
 use App\Jobs\CleanupInstanceStuffsJob;
 use App\Jobs\CleanupStaleMultiplexedConnections;
 use App\Jobs\DatabaseBackupJob;
 use App\Jobs\DockerCleanupJob;
-use App\Jobs\PullHelperImageJob;
-use App\Jobs\PullSentinelImageJob;
 use App\Jobs\PullTemplatesFromCDN;
 use App\Jobs\ScheduledTaskJob;
 use App\Jobs\ServerCheckJob;
+use App\Jobs\ServerCleanupMux;
 use App\Jobs\ServerStorageCheckJob;
 use App\Jobs\UpdateCoolifyJob;
+use App\Models\InstanceSettings;
 use App\Models\ScheduledDatabaseBackup;
 use App\Models\ScheduledTask;
 use App\Models\Server;
 use App\Models\Team;
 use Illuminate\Console\Scheduling\Schedule;
 use Illuminate\Foundation\Console\Kernel as ConsoleKernel;
+use Illuminate\Support\Carbon;
 
 class Kernel extends ConsoleKernel
 {
-    private $all_servers;
+    private $allServers;
+
+    private Schedule $scheduleInstance;
+
+    private InstanceSettings $settings;
+
+    private string $updateCheckFrequency;
+
+    private string $instanceTimezone;
 
     protected function schedule(Schedule $schedule): void
     {
-        $this->all_servers = Server::all();
-        $settings = instanceSettings();
+        $this->scheduleInstance = $schedule;
+        $this->allServers = Server::where('ip', '!=', '1.2.3.4');
 
-        $schedule->job(new CleanupStaleMultiplexedConnections)->hourly();
+        $this->settings = instanceSettings();
+        $this->updateCheckFrequency = $this->settings->update_check_frequency ?: '0 * * * *';
+
+        $this->instanceTimezone = $this->settings->instance_timezone ?: config('app.timezone');
+
+        if (validate_timezone($this->instanceTimezone) === false) {
+            $this->instanceTimezone = config('app.timezone');
+        }
+
+        // $this->scheduleInstance->job(new CleanupStaleMultiplexedConnections)->hourly();
 
         if (isDev()) {
             // Instance Jobs
-            $schedule->command('horizon:snapshot')->everyMinute();
-            $schedule->job(new CleanupInstanceStuffsJob)->everyMinute()->onOneServer();
+            $this->scheduleInstance->command('horizon:snapshot')->everyMinute();
+            $this->scheduleInstance->job(new CleanupInstanceStuffsJob)->everyMinute()->onOneServer();
+            $this->scheduleInstance->job(new CheckHelperImageJob)->everyTenMinutes()->onOneServer();
+
             // Server Jobs
-            $this->check_scheduled_backups($schedule);
-            $this->check_resources($schedule);
-            $this->check_scheduled_tasks($schedule);
-            $schedule->command('uploads:clear')->everyTwoMinutes();
+            $this->checkResources();
 
-            $schedule->command('telescope:prune')->daily();
+            $this->checkScheduledBackups();
+            $this->checkScheduledTasks();
+
+            $this->scheduleInstance->command('uploads:clear')->everyTwoMinutes();
 
-            $schedule->job(new PullHelperImageJob)->everyFiveMinutes()->onOneServer();
         } else {
             // Instance Jobs
-            $schedule->command('horizon:snapshot')->everyFiveMinutes();
-            $schedule->command('cleanup:unreachable-servers')->daily()->onOneServer();
-            $schedule->job(new PullTemplatesFromCDN)->cron($settings->update_check_frequency)->timezone($settings->instance_timezone)->onOneServer();
-            $schedule->job(new CleanupInstanceStuffsJob)->everyTwoMinutes()->onOneServer();
-            $this->schedule_updates($schedule);
+            $this->scheduleInstance->command('horizon:snapshot')->everyFiveMinutes();
+            $this->scheduleInstance->command('cleanup:unreachable-servers')->daily()->onOneServer();
+
+            $this->scheduleInstance->job(new PullTemplatesFromCDN)->cron($this->updateCheckFrequency)->timezone($this->instanceTimezone)->onOneServer();
+
+            $this->scheduleInstance->job(new CleanupInstanceStuffsJob)->everyTwoMinutes()->onOneServer();
+            $this->scheduleUpdates();
 
             // Server Jobs
-            $this->check_scheduled_backups($schedule);
-            $this->check_resources($schedule);
-            $this->pull_images($schedule);
-            $this->check_scheduled_tasks($schedule);
+            $this->checkResources();
 
-            $schedule->command('cleanup:database --yes')->daily();
-            $schedule->command('uploads:clear')->everyTwoMinutes();
+            $this->pullImages();
+
+            $this->checkScheduledBackups();
+            $this->checkScheduledTasks();
+
+            $this->scheduleInstance->command('cleanup:database --yes')->daily();
+            $this->scheduleInstance->command('uploads:clear')->everyTwoMinutes();
         }
     }
 
-    private function pull_images($schedule)
+    private function pullImages(): void
     {
-        $settings = instanceSettings();
-        $servers = $this->all_servers->where('settings.is_usable', true)->where('settings.is_reachable', true)->where('ip', '!=', '1.2.3.4');
+        $servers = $this->allServers->whereRelation('settings', 'is_usable', true)->whereRelation('settings', 'is_reachable', true)->get();
         foreach ($servers as $server) {
             if ($server->isSentinelEnabled()) {
-                $schedule->job(function () use ($server) {
-                    $sentinel_found = instant_remote_process(['docker inspect coolify-sentinel'], $server, false);
-                    $sentinel_found = json_decode($sentinel_found, true);
-                    $status = data_get($sentinel_found, '0.State.Status', 'exited');
-                    if ($status !== 'running') {
-                        PullSentinelImageJob::dispatch($server);
-                    }
-                })->cron($settings->update_check_frequency)->timezone($settings->instance_timezone)->onOneServer();
+                $this->scheduleInstance->job(function () use ($server) {
+                    CheckAndStartSentinelJob::dispatch($server);
+                })->cron($this->updateCheckFrequency)->timezone($this->instanceTimezone)->onOneServer();
             }
         }
-        $schedule->job(new PullHelperImageJob)
-            ->cron($settings->update_check_frequency)
-            ->timezone($settings->instance_timezone)
+        $this->scheduleInstance->job(new CheckHelperImageJob)
+            ->cron($this->updateCheckFrequency)
+            ->timezone($this->instanceTimezone)
             ->onOneServer();
     }
 
-    private function schedule_updates($schedule)
+    private function scheduleUpdates(): void
     {
-        $settings = instanceSettings();
-
-        $updateCheckFrequency = $settings->update_check_frequency;
-        $schedule->job(new CheckForUpdatesJob)
-            ->cron($updateCheckFrequency)
-            ->timezone($settings->instance_timezone)
+        $this->scheduleInstance->job(new CheckForUpdatesJob)
+            ->cron($this->updateCheckFrequency)
+            ->timezone($this->instanceTimezone)
             ->onOneServer();
 
-        if ($settings->is_auto_update_enabled) {
-            $autoUpdateFrequency = $settings->auto_update_frequency;
-            $schedule->job(new UpdateCoolifyJob)
+        if ($this->settings->is_auto_update_enabled) {
+            $autoUpdateFrequency = $this->settings->auto_update_frequency;
+            $this->scheduleInstance->job(new UpdateCoolifyJob)
                 ->cron($autoUpdateFrequency)
-                ->timezone($settings->instance_timezone)
+                ->timezone($this->instanceTimezone)
                 ->onOneServer();
         }
     }
 
-    private function check_resources($schedule)
+    private function checkResources(): void
     {
         if (isCloud()) {
-            $servers = $this->all_servers->whereNotNull('team.subscription')->where('team.subscription.stripe_trial_already_ended', false)->where('ip', '!=', '1.2.3.4');
+            $servers = $this->allServers->whereHas('team.subscription')->get();
             $own = Team::find(0)->servers;
             $servers = $servers->merge($own);
         } else {
-            $servers = $this->all_servers->where('ip', '!=', '1.2.3.4');
+            $servers = $this->allServers->get();
         }
+
         foreach ($servers as $server) {
-            $schedule->job(new ServerCheckJob($server))->everyMinute()->onOneServer();
-            // $schedule->job(new ServerStorageCheckJob($server))->everyMinute()->onOneServer();
-            $serverTimezone = $server->settings->server_timezone;
+            $serverTimezone = data_get($server->settings, 'server_timezone', $this->instanceTimezone);
+
+            // Sentinel check
+            $lastSentinelUpdate = $server->sentinel_updated_at;
+            if (Carbon::parse($lastSentinelUpdate)->isBefore(now()->subSeconds($server->waitBeforeDoingSshCheck()))) {
+                // Check container status every minute if Sentinel does not activated
+                if (validate_timezone($serverTimezone) === false) {
+                    $serverTimezone = config('app.timezone');
+                }
+                if (isCloud()) {
+                    $this->scheduleInstance->job(new ServerCheckJob($server))->timezone($serverTimezone)->everyFiveMinutes()->onOneServer();
+                } else {
+                    $this->scheduleInstance->job(new ServerCheckJob($server))->timezone($serverTimezone)->everyMinute()->onOneServer();
+                }
+                // $this->scheduleInstance->job(new \App\Jobs\ServerCheckNewJob($server))->everyFiveMinutes()->onOneServer();
+
+                // Check storage usage every 10 minutes if Sentinel does not activated
+                $this->scheduleInstance->job(new ServerStorageCheckJob($server))->everyTenMinutes()->onOneServer();
+            }
             if ($server->settings->force_docker_cleanup) {
-                $schedule->job(new DockerCleanupJob($server))->cron($server->settings->docker_cleanup_frequency)->timezone($serverTimezone)->onOneServer();
+                $this->scheduleInstance->job(new DockerCleanupJob($server))->cron($server->settings->docker_cleanup_frequency)->timezone($serverTimezone)->onOneServer();
             } else {
-                $schedule->job(new DockerCleanupJob($server))->everyTenMinutes()->timezone($serverTimezone)->onOneServer();
+                $this->scheduleInstance->job(new DockerCleanupJob($server))->everyTenMinutes()->timezone($serverTimezone)->onOneServer();
+            }
+
+            // Cleanup multiplexed connections every hour
+            // $this->scheduleInstance->job(new ServerCleanupMux($server))->hourly()->onOneServer();
+
+            // Temporary solution until we have better memory management for Sentinel
+            if ($server->isSentinelEnabled()) {
+                $this->scheduleInstance->job(function () use ($server) {
+                    $server->restartContainer('coolify-sentinel');
+                })->daily()->onOneServer();
             }
         }
     }
 
-    private function check_scheduled_backups($schedule)
+    private function checkScheduledBackups(): void
     {
-        $scheduled_backups = ScheduledDatabaseBackup::all();
+        $scheduled_backups = ScheduledDatabaseBackup::where('enabled', true)->get();
         if ($scheduled_backups->isEmpty()) {
             return;
         }
         foreach ($scheduled_backups as $scheduled_backup) {
-            if (! $scheduled_backup->enabled) {
-                continue;
-            }
             if (is_null(data_get($scheduled_backup, 'database'))) {
-                ray('database not found');
                 $scheduled_backup->delete();
 
                 continue;
@@ -145,35 +184,30 @@ private function check_scheduled_backups($schedule)
 
             $server = $scheduled_backup->server();
 
-            if (! $server) {
+            if (is_null($server)) {
                 continue;
             }
-            $serverTimezone = $server->settings->server_timezone;
 
             if (isset(VALID_CRON_STRINGS[$scheduled_backup->frequency])) {
                 $scheduled_backup->frequency = VALID_CRON_STRINGS[$scheduled_backup->frequency];
             }
-            $schedule->job(new DatabaseBackupJob(
+            $this->scheduleInstance->job(new DatabaseBackupJob(
                 backup: $scheduled_backup
-            ))->cron($scheduled_backup->frequency)->timezone($serverTimezone)->onOneServer();
+            ))->cron($scheduled_backup->frequency)->timezone($this->instanceTimezone)->onOneServer();
         }
     }
 
-    private function check_scheduled_tasks($schedule)
+    private function checkScheduledTasks(): void
     {
-        $scheduled_tasks = ScheduledTask::all();
+        $scheduled_tasks = ScheduledTask::where('enabled', true)->get();
         if ($scheduled_tasks->isEmpty()) {
             return;
         }
         foreach ($scheduled_tasks as $scheduled_task) {
-            if ($scheduled_task->enabled === false) {
-                continue;
-            }
             $service = $scheduled_task->service;
             $application = $scheduled_task->application;
 
             if (! $application && ! $service) {
-                ray('application/service attached to scheduled task does not exist');
                 $scheduled_task->delete();
 
                 continue;
@@ -193,14 +227,13 @@ private function check_scheduled_tasks($schedule)
             if (! $server) {
                 continue;
             }
-            $serverTimezone = $server->settings->server_timezone ?: config('app.timezone');
 
             if (isset(VALID_CRON_STRINGS[$scheduled_task->frequency])) {
                 $scheduled_task->frequency = VALID_CRON_STRINGS[$scheduled_task->frequency];
             }
-            $schedule->job(new ScheduledTaskJob(
+            $this->scheduleInstance->job(new ScheduledTaskJob(
                 task: $scheduled_task
-            ))->cron($scheduled_task->frequency)->timezone($serverTimezone)->onOneServer();
+            ))->cron($scheduled_task->frequency)->timezone($this->instanceTimezone)->onOneServer();
         }
     }
 

app/Enums/Role.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Enums;
+
+enum Role: string
+{
+    case MEMBER = 'member';
+    case ADMIN = 'admin';
+    case OWNER = 'owner';
+
+    public function rank(): int
+    {
+        return match ($this) {
+            self::MEMBER => 1,
+            self::ADMIN => 2,
+            self::OWNER => 3,
+        };
+    }
+
+    public function lt(Role|string $role): bool
+    {
+        if (is_string($role)) {
+            $role = Role::from($role);
+        }
+
+        return $this->rank() < $role->rank();
+    }
+
+    public function gt(Role|string $role): bool
+    {
+        if (is_string($role)) {
+            $role = Role::from($role);
+        }
+
+        return $this->rank() > $role->rank();
+    }
+}

app/Events/DatabaseProxyStopped.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Events;
+
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Broadcasting\PrivateChannel;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Auth;
+
+class DatabaseProxyStopped implements ShouldBroadcast
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public $teamId;
+
+    public function __construct($teamId = null)
+    {
+        if (is_null($teamId)) {
+            $teamId = Auth::user()?->currentTeam()?->id ?? null;
+        }
+        if (is_null($teamId)) {
+            throw new \Exception('Team id is null');
+        }
+        $this->teamId = $teamId;
+    }
+
+    public function broadcastOn(): array
+    {
+        return [
+            new PrivateChannel("team.{$this->teamId}"),
+        ];
+    }
+}

app/Events/DatabaseStatusChanged.php

@@ -7,27 +7,29 @@
 use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
 use Illuminate\Foundation\Events\Dispatchable;
 use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Auth;
 
 class DatabaseStatusChanged implements ShouldBroadcast
 {
     use Dispatchable, InteractsWithSockets, SerializesModels;
 
-    public ?string $userId = null;
+    public $userId = null;
 
     public function __construct($userId = null)
     {
         if (is_null($userId)) {
-            $userId = auth()->user()->id ?? null;
+            $userId = Auth::id() ?? null;
         }
         if (is_null($userId)) {
             return false;
         }
+
         $this->userId = $userId;
     }
 
     public function broadcastOn(): ?array
     {
-        if ($this->userId) {
+        if (! is_null($this->userId)) {
             return [
                 new PrivateChannel("user.{$this->userId}"),
             ];

app/Events/FileStorageChanged.php

@@ -16,7 +16,6 @@ class FileStorageChanged implements ShouldBroadcast
 
     public function __construct($teamId = null)
     {
-        ray($teamId);
         if (is_null($teamId)) {
             throw new \Exception('Team id is null');
         }

app/Events/ScheduledTaskDone.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Events;
+
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Broadcasting\PrivateChannel;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class ScheduledTaskDone implements ShouldBroadcast
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public $teamId;
+
+    public function __construct($teamId = null)
+    {
+        if (is_null($teamId)) {
+            $teamId = auth()->user()->currentTeam()->id ?? null;
+        }
+        if (is_null($teamId)) {
+            throw new \Exception('Team id is null');
+        }
+        $this->teamId = $teamId;
+    }
+
+    public function broadcastOn(): array
+    {
+        return [
+            new PrivateChannel("team.{$this->teamId}"),
+        ];
+    }
+}

app/Events/ServiceStatusChanged.php

@@ -7,6 +7,7 @@
 use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
 use Illuminate\Foundation\Events\Dispatchable;
 use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Auth;
 
 class ServiceStatusChanged implements ShouldBroadcast
 {
@@ -17,7 +18,7 @@ class ServiceStatusChanged implements ShouldBroadcast
     public function __construct($userId = null)
     {
         if (is_null($userId)) {
-            $userId = auth()->user()->id ?? null;
+            $userId = Auth::id() ?? null;
         }
         if (is_null($userId)) {
             return false;

app/Exceptions/Handler.php

@@ -84,7 +84,6 @@ function (Scope $scope) {
             if (str($e->getMessage())->contains('No space left on device')) {
                 return;
             }
-            ray('reporting to sentry');
             Integration::captureUnhandledException($e);
         });
     }

app/Helpers/SshMultiplexingHelper.php

@@ -21,17 +21,14 @@ public static function serverSshConfiguration(Server $server)
         ];
     }
 
-    public static function ensureMultiplexedConnection(Server $server)
+    public static function ensureMultiplexedConnection(Server $server): bool
     {
         if (! self::isMultiplexingEnabled()) {
-            return;
+            return false;
         }
 
         $sshConfig = self::serverSshConfiguration($server);
         $muxSocket = $sshConfig['muxFilename'];
-        $sshKeyLocation = $sshConfig['sshKeyLocation'];
-
-        self::validateSshKey($sshKeyLocation);
 
         $checkCommand = "ssh -O check -o ControlPath=$muxSocket ";
         if (data_get($server, 'settings.is_cloudflare_tunnel')) {
@@ -41,16 +38,17 @@ public static function ensureMultiplexedConnection(Server $server)
         $process = Process::run($checkCommand);
 
         if ($process->exitCode() !== 0) {
-            self::establishNewMultiplexedConnection($server);
+            return self::establishNewMultiplexedConnection($server);
         }
+
+        return true;
     }
 
-    public static function establishNewMultiplexedConnection(Server $server)
+    public static function establishNewMultiplexedConnection(Server $server): bool
     {
         $sshConfig = self::serverSshConfiguration($server);
         $sshKeyLocation = $sshConfig['sshKeyLocation'];
         $muxSocket = $sshConfig['muxFilename'];
-
         $connectionTimeout = config('constants.ssh.connection_timeout');
         $serverInterval = config('constants.ssh.server_interval');
         $muxPersistTime = config('constants.ssh.mux_persist_time');
@@ -60,15 +58,14 @@ public static function establishNewMultiplexedConnection(Server $server)
         if (data_get($server, 'settings.is_cloudflare_tunnel')) {
             $establishCommand .= ' -o ProxyCommand="cloudflared access ssh --hostname %h" ';
         }
-
         $establishCommand .= self::getCommonSshOptions($server, $sshKeyLocation, $connectionTimeout, $serverInterval);
         $establishCommand .= "{$server->user}@{$server->ip}";
-
         $establishProcess = Process::run($establishCommand);
-
         if ($establishProcess->exitCode() !== 0) {
-            throw new \RuntimeException('Failed to establish multiplexed connection: '.$establishProcess->errorOutput());
+            return false;
         }
+
+        return true;
     }
 
     public static function removeMuxFile(Server $server)
@@ -97,9 +94,8 @@ public static function generateScpCommand(Server $server, string $source, string
         if ($server->isIpv6()) {
             $scp_command .= '-6 ';
         }
-        if (self::isMultiplexingEnabled()) {
+        if (self::isMultiplexingEnabled() && self::ensureMultiplexedConnection($server)) {
             $scp_command .= "-o ControlMaster=auto -o ControlPath=$muxSocket -o ControlPersist={$muxPersistTime} ";
-            self::ensureMultiplexedConnection($server);
         }
 
         if (data_get($server, 'settings.is_cloudflare_tunnel')) {
@@ -120,6 +116,9 @@ public static function generateSshCommand(Server $server, string $command)
 
         $sshConfig = self::serverSshConfiguration($server);
         $sshKeyLocation = $sshConfig['sshKeyLocation'];
+
+        self::validateSshKey($server->privateKey);
+
         $muxSocket = $sshConfig['muxFilename'];
 
         $timeout = config('constants.ssh.command_timeout');
@@ -127,9 +126,8 @@ public static function generateSshCommand(Server $server, string $command)
 
         $ssh_command = "timeout $timeout ssh ";
 
-        if (self::isMultiplexingEnabled()) {
+        if (self::isMultiplexingEnabled() && self::ensureMultiplexedConnection($server)) {
             $ssh_command .= "-o ControlMaster=auto -o ControlPath=$muxSocket -o ControlPersist={$muxPersistTime} ";
-            self::ensureMultiplexedConnection($server);
         }
 
         if (data_get($server, 'settings.is_cloudflare_tunnel')) {
@@ -151,16 +149,17 @@ public static function generateSshCommand(Server $server, string $command)
 
     private static function isMultiplexingEnabled(): bool
     {
-        return config('constants.ssh.mux_enabled') && ! config('coolify.is_windows_docker_desktop');
+        return config('constants.ssh.mux_enabled') && ! config('constants.coolify.is_windows_docker_desktop');
     }
 
-    private static function validateSshKey(string $sshKeyLocation): void
+    private static function validateSshKey(PrivateKey $privateKey): void
     {
-        $checkKeyCommand = "ls $sshKeyLocation 2>/dev/null";
+        $keyLocation = $privateKey->getKeyLocation();
+        $checkKeyCommand = "ls $keyLocation 2>/dev/null";
         $keyCheckProcess = Process::run($checkKeyCommand);
 
         if ($keyCheckProcess->exitCode() !== 0) {
-            throw new \RuntimeException("SSH key file not accessible: $sshKeyLocation");
+            $privateKey->storeInFileSystem();
         }
     }
 

app/Http/Controllers/Api/ApplicationsController.php

@@ -25,26 +25,24 @@ class ApplicationsController extends Controller
 {
     private function removeSensitiveData($application)
     {
-        $token = auth()->user()->currentAccessToken();
         $application->makeHidden([
             'id',
         ]);
-        if ($token->can('view:sensitive')) {
-            return serializeApiResponse($application);
+        if (request()->attributes->get('can_read_sensitive', false) === false) {
+            $application->makeHidden([
+                'custom_labels',
+                'dockerfile',
+                'docker_compose',
+                'docker_compose_raw',
+                'manual_webhook_secret_bitbucket',
+                'manual_webhook_secret_gitea',
+                'manual_webhook_secret_github',
+                'manual_webhook_secret_gitlab',
+                'private_key_id',
+                'value',
+                'real_value',
+            ]);
         }
-        $application->makeHidden([
-            'custom_labels',
-            'dockerfile',
-            'docker_compose',
-            'docker_compose_raw',
-            'manual_webhook_secret_bitbucket',
-            'manual_webhook_secret_gitea',
-            'manual_webhook_secret_github',
-            'manual_webhook_secret_gitlab',
-            'private_key_id',
-            'value',
-            'real_value',
-        ]);
 
         return serializeApiResponse($application);
     }
@@ -70,7 +68,8 @@ private function removeSensitiveData($application)
                             items: new OA\Items(ref: '#/components/schemas/Application')
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -180,8 +179,10 @@ public function applications(Request $request)
                             'watch_paths' => ['type' => 'string', 'description' => 'The watch paths.'],
                             'use_build_server' => ['type' => 'boolean', 'nullable' => true, 'description' => 'Use build server.'],
                         ],
-                    )),
-            ]),
+                    )
+                ),
+            ]
+        ),
         responses: [
             new OA\Response(
                 response: 200,
@@ -284,8 +285,10 @@ public function create_public_application(Request $request)
                             'watch_paths' => ['type' => 'string', 'description' => 'The watch paths.'],
                             'use_build_server' => ['type' => 'boolean', 'nullable' => true, 'description' => 'Use build server.'],
                         ],
-                    )),
-            ]),
+                    )
+                ),
+            ]
+        ),
         responses: [
             new OA\Response(
                 response: 200,
@@ -388,8 +391,10 @@ public function create_private_gh_app_application(Request $request)
                             'watch_paths' => ['type' => 'string', 'description' => 'The watch paths.'],
                             'use_build_server' => ['type' => 'boolean', 'nullable' => true, 'description' => 'Use build server.'],
                         ],
-                    )),
-            ]),
+                    )
+                ),
+            ]
+        ),
         responses: [
             new OA\Response(
                 response: 200,
@@ -476,8 +481,10 @@ public function create_private_deploy_key_application(Request $request)
                             'instant_deploy' => ['type' => 'boolean', 'description' => 'The flag to indicate if the application should be deployed instantly.'],
                             'use_build_server' => ['type' => 'boolean', 'nullable' => true, 'description' => 'Use build server.'],
                         ],
-                    )),
-            ]),
+                    )
+                ),
+            ]
+        ),
         responses: [
             new OA\Response(
                 response: 200,
@@ -561,8 +568,10 @@ public function create_dockerfile_application(Request $request)
                             'instant_deploy' => ['type' => 'boolean', 'description' => 'The flag to indicate if the application should be deployed instantly.'],
                             'use_build_server' => ['type' => 'boolean', 'nullable' => true, 'description' => 'Use build server.'],
                         ],
-                    )),
-            ]),
+                    )
+                ),
+            ]
+        ),
         responses: [
             new OA\Response(
                 response: 200,
@@ -612,8 +621,10 @@ public function create_dockerimage_application(Request $request)
                             'instant_deploy' => ['type' => 'boolean', 'description' => 'The flag to indicate if the application should be deployed instantly.'],
                             'use_build_server' => ['type' => 'boolean', 'nullable' => true, 'description' => 'Use build server.'],
                         ],
-                    )),
-            ]),
+                    )
+                ),
+            ]
+        ),
         responses: [
             new OA\Response(
                 response: 200,
@@ -636,7 +647,7 @@ public function create_dockercompose_application(Request $request)
 
     private function create_application(Request $request, $type)
     {
-        $allowedFields = ['project_uuid', 'environment_name', 'server_uuid', 'destination_uuid', 'type', 'name', 'description', 'is_static', 'domains', 'git_repository', 'git_branch', 'git_commit_sha', 'private_key_uuid', 'docker_registry_image_name', 'docker_registry_image_tag', 'build_pack', 'install_command', 'build_command', 'start_command', 'ports_exposes', 'ports_mappings', 'base_directory', 'publish_directory', 'health_check_enabled', 'health_check_path', 'health_check_port', 'health_check_host', 'health_check_method', 'health_check_return_code', 'health_check_scheme', 'health_check_response_text', 'health_check_interval', 'health_check_timeout', 'health_check_retries', 'health_check_start_period', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'custom_labels', 'custom_docker_run_options', 'post_deployment_command', 'post_deployment_command_container', 'pre_deployment_command', 'pre_deployment_command_container',  'manual_webhook_secret_github', 'manual_webhook_secret_gitlab', 'manual_webhook_secret_bitbucket', 'manual_webhook_secret_gitea', 'redirect', 'github_app_uuid', 'instant_deploy', 'dockerfile', 'docker_compose_location', 'docker_compose_raw', 'docker_compose_custom_start_command', 'docker_compose_custom_build_command', 'docker_compose_domains', 'watch_paths', 'use_build_server', 'static_image'];
+        $allowedFields = ['project_uuid', 'environment_name', 'server_uuid', 'destination_uuid', 'type', 'name', 'description', 'is_static', 'domains', 'git_repository', 'git_branch', 'git_commit_sha', 'private_key_uuid', 'docker_registry_image_name', 'docker_registry_image_tag', 'build_pack', 'install_command', 'build_command', 'start_command', 'ports_exposes', 'ports_mappings', 'base_directory', 'publish_directory', 'health_check_enabled', 'health_check_path', 'health_check_port', 'health_check_host', 'health_check_method', 'health_check_return_code', 'health_check_scheme', 'health_check_response_text', 'health_check_interval', 'health_check_timeout', 'health_check_retries', 'health_check_start_period', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'custom_labels', 'custom_docker_run_options', 'post_deployment_command', 'post_deployment_command_container', 'pre_deployment_command', 'pre_deployment_command_container',  'manual_webhook_secret_github', 'manual_webhook_secret_gitlab', 'manual_webhook_secret_bitbucket', 'manual_webhook_secret_gitea', 'redirect', 'github_app_uuid', 'instant_deploy', 'dockerfile', 'docker_compose_location', 'docker_compose_raw', 'docker_compose_custom_start_command', 'docker_compose_custom_build_command', 'docker_compose_domains', 'watch_paths', 'use_build_server', 'static_image', 'custom_nginx_configuration'];
         $teamId = getTeamIdFromToken();
         if (is_null($teamId)) {
             return invalidTokenResponse();
@@ -676,6 +687,27 @@ private function create_application(Request $request, $type)
         $githubAppUuid = $request->github_app_uuid;
         $useBuildServer = $request->use_build_server;
         $isStatic = $request->is_static;
+        $customNginxConfiguration = $request->custom_nginx_configuration;
+
+        if (! is_null($customNginxConfiguration)) {
+            if (! isBase64Encoded($customNginxConfiguration)) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => [
+                        'custom_nginx_configuration' => 'The custom_nginx_configuration should be base64 encoded.',
+                    ],
+                ], 422);
+            }
+            $customNginxConfiguration = base64_decode($customNginxConfiguration);
+            if (mb_detect_encoding($customNginxConfiguration, 'ASCII', true) === false) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => [
+                        'custom_nginx_configuration' => 'The custom_nginx_configuration should be base64 encoded.',
+                    ],
+                ], 422);
+            }
+        }
 
         $project = Project::whereTeamId($teamId)->whereUuid($request->project_uuid)->first();
         if (! $project) {
@@ -1213,7 +1245,6 @@ private function create_application(Request $request, $type)
         }
 
         return response()->json(['message' => 'Invalid type.'], 400);
-
     }
 
     #[OA\Get(
@@ -1248,7 +1279,8 @@ private function create_application(Request $request, $type)
                             ref: '#/components/schemas/Application'
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1320,7 +1352,8 @@ public function application_by_uuid(Request $request)
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1446,8 +1479,10 @@ public function delete_by_uuid(Request $request)
                             'watch_paths' => ['type' => 'string', 'description' => 'The watch paths.'],
                             'use_build_server' => ['type' => 'boolean', 'nullable' => true, 'description' => 'Use build server.'],
                         ],
-                    )),
-            ]),
+                    )
+                ),
+            ]
+        ),
         responses: [
             new OA\Response(
                 response: 200,
@@ -1462,7 +1497,8 @@ public function delete_by_uuid(Request $request)
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1501,7 +1537,7 @@ public function update_by_uuid(Request $request)
             ], 404);
         }
         $server = $application->destination->server;
-        $allowedFields = ['name', 'description', 'is_static', 'domains', 'git_repository', 'git_branch', 'git_commit_sha', 'docker_registry_image_name', 'docker_registry_image_tag', 'build_pack', 'static_image', 'install_command', 'build_command', 'start_command', 'ports_exposes', 'ports_mappings', 'base_directory', 'publish_directory', 'health_check_enabled', 'health_check_path', 'health_check_port', 'health_check_host', 'health_check_method', 'health_check_return_code', 'health_check_scheme', 'health_check_response_text', 'health_check_interval', 'health_check_timeout', 'health_check_retries', 'health_check_start_period', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'custom_labels', 'custom_docker_run_options', 'post_deployment_command', 'post_deployment_command_container', 'pre_deployment_command', 'pre_deployment_command_container', 'watch_paths', 'manual_webhook_secret_github', 'manual_webhook_secret_gitlab', 'manual_webhook_secret_bitbucket', 'manual_webhook_secret_gitea', 'docker_compose_location', 'docker_compose_raw', 'docker_compose_custom_start_command', 'docker_compose_custom_build_command', 'docker_compose_domains', 'redirect', 'instant_deploy', 'use_build_server'];
+        $allowedFields = ['name', 'description', 'is_static', 'domains', 'git_repository', 'git_branch', 'git_commit_sha', 'docker_registry_image_name', 'docker_registry_image_tag', 'build_pack', 'static_image', 'install_command', 'build_command', 'start_command', 'ports_exposes', 'ports_mappings', 'base_directory', 'publish_directory', 'health_check_enabled', 'health_check_path', 'health_check_port', 'health_check_host', 'health_check_method', 'health_check_return_code', 'health_check_scheme', 'health_check_response_text', 'health_check_interval', 'health_check_timeout', 'health_check_retries', 'health_check_start_period', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'custom_labels', 'custom_docker_run_options', 'post_deployment_command', 'post_deployment_command_container', 'pre_deployment_command', 'pre_deployment_command_container', 'watch_paths', 'manual_webhook_secret_github', 'manual_webhook_secret_gitlab', 'manual_webhook_secret_bitbucket', 'manual_webhook_secret_gitea', 'docker_compose_location', 'docker_compose_raw', 'docker_compose_custom_start_command', 'docker_compose_custom_build_command', 'docker_compose_domains', 'redirect', 'instant_deploy', 'use_build_server', 'custom_nginx_configuration'];
 
         $validationRules = [
             'name' => 'string|max:255',
@@ -1513,6 +1549,7 @@ public function update_by_uuid(Request $request)
             'docker_compose_domains' => 'array|nullable',
             'docker_compose_custom_start_command' => 'string|nullable',
             'docker_compose_custom_build_command' => 'string|nullable',
+            'custom_nginx_configuration' => 'string|nullable',
         ];
         $validationRules = array_merge($validationRules, sharedDataApplications());
         $validator = customApiValidator($request->all(), $validationRules);
@@ -1531,6 +1568,25 @@ public function update_by_uuid(Request $request)
                 }
             }
         }
+        if ($request->has('custom_nginx_configuration')) {
+            if (! isBase64Encoded($request->custom_nginx_configuration)) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => [
+                        'custom_nginx_configuration' => 'The custom_nginx_configuration should be base64 encoded.',
+                    ],
+                ], 422);
+            }
+            $customNginxConfiguration = base64_decode($request->custom_nginx_configuration);
+            if (mb_detect_encoding($customNginxConfiguration, 'ASCII', true) === false) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => [
+                        'custom_nginx_configuration' => 'The custom_nginx_configuration should be base64 encoded.',
+                    ],
+                ], 422);
+            }
+        }
         $return = $this->validateDataApplications($request, $server);
         if ($return instanceof \Illuminate\Http\JsonResponse) {
             return $return;
@@ -1551,16 +1607,33 @@ public function update_by_uuid(Request $request)
         }
         $domains = $request->domains;
         if ($request->has('domains') && $server->isProxyShouldRun()) {
-            $errors = [];
+            $uuid = $request->uuid;
             $fqdn = $request->domains;
             $fqdn = str($fqdn)->replaceEnd(',', '')->trim();
             $fqdn = str($fqdn)->replaceStart(',', '')->trim();
-            $application->fqdn = $fqdn;
-            if (! $application->settings->is_container_label_readonly_enabled) {
-                $customLabels = str(implode('|coolify|', generateLabelsApplication($application)))->replace('|coolify|', "\n");
-                $application->custom_labels = base64_encode($customLabels);
+            $errors = [];
+            $fqdn = str($fqdn)->trim()->explode(',')->map(function ($domain) use (&$errors) {
+                $domain = trim($domain);
+                if (filter_var($domain, FILTER_VALIDATE_URL) === false || ! preg_match('/^https?:\/\/[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,}/', $domain)) {
+                    $errors[] = 'Invalid domain: '.$domain;
+                }
+
+                return $domain;
+            });
+            if (count($errors) > 0) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => $errors,
+                ], 422);
+            }
+            if (checkIfDomainIsAlreadyUsed($fqdn, $teamId, $uuid)) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => [
+                        'domains' => 'One of the domain is already used.',
+                    ],
+                ], 422);
             }
-            $request->offsetUnset('domains');
         }
 
         $dockerComposeDomainsJson = collect();
@@ -1579,11 +1652,16 @@ public function update_by_uuid(Request $request)
             $request->offsetUnset('docker_compose_domains');
         }
         $instantDeploy = $request->instant_deploy;
+        $isStatic = $request->is_static;
+        $useBuildServer = $request->use_build_server;
 
-        $use_build_server = $request->use_build_server;
+        if (isset($useBuildServer)) {
+            $application->settings->is_build_server_enabled = $useBuildServer;
+            $application->settings->save();
+        }
 
-        if (isset($use_build_server)) {
-            $application->settings->is_build_server_enabled = $use_build_server;
+        if (isset($isStatic)) {
+            $application->settings->is_static = $isStatic;
             $application->settings->save();
         }
 
@@ -1645,7 +1723,8 @@ public function update_by_uuid(Request $request)
                             items: new OA\Items(ref: '#/components/schemas/EnvironmentVariable')
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1687,9 +1766,8 @@ public function envs(Request $request)
                 'standalone_postgresql_id',
                 'standalone_redis_id',
             ]);
-            $env = $this->removeSensitiveData($env);
 
-            return $env;
+            return $this->removeSensitiveData($env);
         });
 
         return response()->json($envs);
@@ -1752,7 +1830,8 @@ public function envs(Request $request)
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1864,18 +1943,15 @@ public function update_env_by_uuid(Request $request)
 
                 return response()->json($this->removeSensitiveData($env))->setStatusCode(201);
             } else {
-
                 return response()->json([
                     'message' => 'Environment variable not found.',
                 ], 404);
-
             }
         }
 
         return response()->json([
             'message' => 'Something is not okay. Are you okay?',
         ], 500);
-
     }
 
     #[OA\Patch(
@@ -1943,7 +2019,8 @@ public function update_env_by_uuid(Request $request)
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -2124,7 +2201,8 @@ public function create_bulk_envs(Request $request)
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -2220,14 +2298,12 @@ public function create_env(Request $request)
                 return response()->json([
                     'uuid' => $env->uuid,
                 ])->setStatusCode(201);
-
             }
         }
 
         return response()->json([
             'message' => 'Something went wrong.',
         ], 500);
-
     }
 
     #[OA\Delete(
@@ -2275,7 +2351,8 @@ public function create_env(Request $request)
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -2367,9 +2444,11 @@ public function delete_env_by_uuid(Request $request)
                             properties: [
                                 'message' => ['type' => 'string', 'example' => 'Deployment request queued.', 'description' => 'Message.'],
                                 'deployment_uuid' => ['type' => 'string', 'example' => 'doogksw', 'description' => 'UUID of the deployment.'],
-                            ])
+                            ]
+                        )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -2455,7 +2534,8 @@ public function action_deploy(Request $request)
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -2529,7 +2609,8 @@ public function action_stop(Request $request)
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
 
             new OA\Response(
                 response: 401,
@@ -2575,7 +2656,6 @@ public function action_restart(Request $request)
                 'deployment_uuid' => $deployment_uuid->toString(),
             ],
         );
-
     }
 
     #[OA\Post(
@@ -2741,7 +2821,6 @@ private function validateDataApplications(Request $request, Server $server)
                         'custom_labels' => 'The custom_labels should be base64 encoded.',
                     ],
                 ], 422);
-
             }
         }
         if ($request->has('domains') && $server->isProxyShouldRun()) {

app/Http/Controllers/Api/DatabasesController.php

@@ -19,26 +19,23 @@ class DatabasesController extends Controller
 {
     private function removeSensitiveData($database)
     {
-        $token = auth()->user()->currentAccessToken();
         $database->makeHidden([
             'id',
             'laravel_through_key',
         ]);
-        if ($token->can('view:sensitive')) {
-            return serializeApiResponse($database);
+        if (request()->attributes->get('can_read_sensitive', false) === false) {
+            $database->makeHidden([
+                'internal_db_url',
+                'external_db_url',
+                'postgres_password',
+                'dragonfly_password',
+                'redis_password',
+                'mongo_initdb_root_password',
+                'keydb_password',
+                'clickhouse_admin_password',
+            ]);
         }
 
-        $database->makeHidden([
-            'internal_db_url',
-            'external_db_url',
-            'postgres_password',
-            'dragonfly_password',
-            'redis_password',
-            'mongo_initdb_root_password',
-            'keydb_password',
-            'clickhouse_admin_password',
-        ]);
-
         return serializeApiResponse($database);
     }
 
@@ -211,8 +208,9 @@ public function database_by_uuid(Request $request)
                         'mongo_conf' => ['type' => 'string', 'description' => 'Mongo conf'],
                         'mongo_initdb_root_username' => ['type' => 'string', 'description' => 'Mongo initdb root username'],
                         'mongo_initdb_root_password' => ['type' => 'string', 'description' => 'Mongo initdb root password'],
-                        'mongo_initdb_init_database' => ['type' => 'string', 'description' => 'Mongo initdb init database'],
+                        'mongo_initdb_database' => ['type' => 'string', 'description' => 'Mongo initdb init database'],
                         'mysql_root_password' => ['type' => 'string', 'description' => 'MySQL root password'],
+                        'mysql_password' => ['type' => 'string', 'description' => 'MySQL password'],
                         'mysql_user' => ['type' => 'string', 'description' => 'MySQL user'],
                         'mysql_database' => ['type' => 'string', 'description' => 'MySQL database'],
                         'mysql_conf' => ['type' => 'string', 'description' => 'MySQL conf'],
@@ -241,7 +239,7 @@ public function database_by_uuid(Request $request)
     )]
     public function update_by_uuid(Request $request)
     {
-        $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'postgres_user', 'postgres_password', 'postgres_db', 'postgres_initdb_args', 'postgres_host_auth_method', 'postgres_conf', 'clickhouse_admin_user', 'clickhouse_admin_password', 'dragonfly_password', 'redis_password', 'redis_conf', 'keydb_password', 'keydb_conf', 'mariadb_conf', 'mariadb_root_password', 'mariadb_user', 'mariadb_password', 'mariadb_database', 'mongo_conf', 'mongo_initdb_root_username', 'mongo_initdb_root_password', 'mongo_initdb_init_database', 'mysql_root_password', 'mysql_user', 'mysql_database', 'mysql_conf'];
+        $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'postgres_user', 'postgres_password', 'postgres_db', 'postgres_initdb_args', 'postgres_host_auth_method', 'postgres_conf', 'clickhouse_admin_user', 'clickhouse_admin_password', 'dragonfly_password', 'redis_password', 'redis_conf', 'keydb_password', 'keydb_conf', 'mariadb_conf', 'mariadb_root_password', 'mariadb_user', 'mariadb_password', 'mariadb_database', 'mongo_conf', 'mongo_initdb_root_username', 'mongo_initdb_root_password', 'mongo_initdb_database', 'mysql_root_password', 'mysql_password', 'mysql_user', 'mysql_database', 'mysql_conf'];
         $teamId = getTeamIdFromToken();
         if (is_null($teamId)) {
             return invalidTokenResponse();
@@ -413,12 +411,12 @@ public function update_by_uuid(Request $request)
                 }
                 break;
             case 'standalone-mongodb':
-                $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'mongo_conf', 'mongo_initdb_root_username', 'mongo_initdb_root_password', 'mongo_initdb_init_database'];
+                $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'mongo_conf', 'mongo_initdb_root_username', 'mongo_initdb_root_password', 'mongo_initdb_database'];
                 $validator = customApiValidator($request->all(), [
                     'mongo_conf' => 'string',
                     'mongo_initdb_root_username' => 'string',
                     'mongo_initdb_root_password' => 'string',
-                    'mongo_initdb_init_database' => 'string',
+                    'mongo_initdb_database' => 'string',
                 ]);
                 if ($request->has('mongo_conf')) {
                     if (! isBase64Encoded($request->mongo_conf)) {
@@ -443,9 +441,10 @@ public function update_by_uuid(Request $request)
 
                 break;
             case 'standalone-mysql':
-                $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'mysql_root_password', 'mysql_user', 'mysql_database', 'mysql_conf'];
+                $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'mysql_root_password', 'mysql_password', 'mysql_user', 'mysql_database', 'mysql_conf'];
                 $validator = customApiValidator($request->all(), [
                     'mysql_root_password' => 'string',
+                    'mysql_password' => 'string',
                     'mysql_user' => 'string',
                     'mysql_database' => 'string',
                     'mysql_conf' => 'string',
@@ -471,7 +470,6 @@ public function update_by_uuid(Request $request)
                     $request->offsetSet('mysql_conf', $mysqlConf);
                 }
                 break;
-
         }
         $extraFields = array_diff(array_keys($request->all()), $allowedFields);
         if ($validator->fails() || ! empty($extraFields)) {
@@ -506,7 +504,6 @@ public function update_by_uuid(Request $request)
         return response()->json([
             'message' => 'Database updated.',
         ]);
-
     }
 
     #[OA\Post(
@@ -911,6 +908,7 @@ public function create_database_mariadb(Request $request)
                         'environment_name' => ['type' => 'string', 'description' => 'Name of the environment'],
                         'destination_uuid' => ['type' => 'string', 'description' => 'UUID of the destination if the server has multiple destinations'],
                         'mysql_root_password' => ['type' => 'string', 'description' => 'MySQL root password'],
+                        'mysql_password' => ['type' => 'string', 'description' => 'MySQL password'],
                         'mysql_user' => ['type' => 'string', 'description' => 'MySQL user'],
                         'mysql_database' => ['type' => 'string', 'description' => 'MySQL database'],
                         'mysql_conf' => ['type' => 'string', 'description' => 'MySQL conf'],
@@ -1015,7 +1013,7 @@ public function create_database_mongodb(Request $request)
 
     public function create_database(Request $request, NewDatabaseTypes $type)
     {
-        $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'project_uuid', 'environment_name', 'server_uuid', 'destination_uuid', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'postgres_user', 'postgres_password', 'postgres_db', 'postgres_initdb_args', 'postgres_host_auth_method', 'postgres_conf', 'clickhouse_admin_user', 'clickhouse_admin_password', 'dragonfly_password', 'redis_password', 'redis_conf', 'keydb_password', 'keydb_conf', 'mariadb_conf', 'mariadb_root_password', 'mariadb_user', 'mariadb_password', 'mariadb_database', 'mongo_conf', 'mongo_initdb_root_username', 'mongo_initdb_root_password', 'mongo_initdb_init_database', 'mysql_root_password', 'mysql_user', 'mysql_database', 'mysql_conf'];
+        $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'project_uuid', 'environment_name', 'server_uuid', 'destination_uuid', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'postgres_user', 'postgres_password', 'postgres_db', 'postgres_initdb_args', 'postgres_host_auth_method', 'postgres_conf', 'clickhouse_admin_user', 'clickhouse_admin_password', 'dragonfly_password', 'redis_password', 'redis_conf', 'keydb_password', 'keydb_conf', 'mariadb_conf', 'mariadb_root_password', 'mariadb_user', 'mariadb_password', 'mariadb_database', 'mongo_conf', 'mongo_initdb_root_username', 'mongo_initdb_root_password', 'mongo_initdb_database', 'mysql_root_password', 'mysql_password', 'mysql_user', 'mysql_database', 'mysql_conf'];
 
         $teamId = getTeamIdFromToken();
         if (is_null($teamId)) {
@@ -1165,7 +1163,6 @@ public function create_database(Request $request, NewDatabaseTypes $type)
             }
 
             return response()->json(serializeApiResponse($payload))->setStatusCode(201);
-
         } elseif ($type === NewDatabaseTypes::MARIADB) {
             $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'project_uuid', 'environment_name', 'server_uuid', 'destination_uuid', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'mariadb_conf', 'mariadb_root_password', 'mariadb_user', 'mariadb_password', 'mariadb_database'];
             $validator = customApiValidator($request->all(), [
@@ -1223,9 +1220,10 @@ public function create_database(Request $request, NewDatabaseTypes $type)
 
             return response()->json(serializeApiResponse($payload))->setStatusCode(201);
         } elseif ($type === NewDatabaseTypes::MYSQL) {
-            $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'project_uuid', 'environment_name', 'server_uuid', 'destination_uuid', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'mysql_user', 'mysql_database', 'mysql_conf'];
+            $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'project_uuid', 'environment_name', 'server_uuid', 'destination_uuid', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'mysql_root_password', 'mysql_password', 'mysql_user', 'mysql_database', 'mysql_conf'];
             $validator = customApiValidator($request->all(), [
                 'mysql_root_password' => 'string',
+                'mysql_password' => 'string',
                 'mysql_user' => 'string',
                 'mysql_database' => 'string',
                 'mysql_conf' => 'string',
@@ -1459,12 +1457,12 @@ public function create_database(Request $request, NewDatabaseTypes $type)
 
             return response()->json(serializeApiResponse($payload))->setStatusCode(201);
         } elseif ($type === NewDatabaseTypes::MONGODB) {
-            $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'project_uuid', 'environment_name', 'server_uuid', 'destination_uuid', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'mongo_conf', 'mongo_initdb_root_username', 'mongo_initdb_root_password', 'mongo_initdb_init_database'];
+            $allowedFields = ['name', 'description', 'image', 'public_port', 'is_public', 'project_uuid', 'environment_name', 'server_uuid', 'destination_uuid', 'instant_deploy', 'limits_memory', 'limits_memory_swap', 'limits_memory_swappiness', 'limits_memory_reservation', 'limits_cpus', 'limits_cpuset', 'limits_cpu_shares', 'mongo_conf', 'mongo_initdb_root_username', 'mongo_initdb_root_password', 'mongo_initdb_database'];
             $validator = customApiValidator($request->all(), [
                 'mongo_conf' => 'string',
                 'mongo_initdb_root_username' => 'string',
                 'mongo_initdb_root_password' => 'string',
-                'mongo_initdb_init_database' => 'string',
+                'mongo_initdb_database' => 'string',
             ]);
             $extraFields = array_diff(array_keys($request->all()), $allowedFields);
             if ($validator->fails() || ! empty($extraFields)) {
@@ -1560,7 +1558,8 @@ public function create_database(Request $request, NewDatabaseTypes $type)
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1635,9 +1634,11 @@ public function delete_by_uuid(Request $request)
                             type: 'object',
                             properties: [
                                 'message' => ['type' => 'string', 'example' => 'Database starting request queued.'],
-                            ])
+                            ]
+                        )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1711,9 +1712,11 @@ public function action_deploy(Request $request)
                             type: 'object',
                             properties: [
                                 'message' => ['type' => 'string', 'example' => 'Database stopping request queued.'],
-                            ])
+                            ]
+                        )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1787,9 +1790,11 @@ public function action_stop(Request $request)
                             type: 'object',
                             properties: [
                                 'message' => ['type' => 'string', 'example' => 'Database restaring request queued.'],
-                            ])
+                            ]
+                        )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1826,6 +1831,5 @@ public function action_restart(Request $request)
             ],
             200
         );
-
     }
 }

app/Http/Controllers/Api/DeployController.php

@@ -16,15 +16,12 @@ class DeployController extends Controller
 {
     private function removeSensitiveData($deployment)
     {
-        $token = auth()->user()->currentAccessToken();
-        if ($token->can('view:sensitive')) {
-            return serializeApiResponse($deployment);
+        if (request()->attributes->get('can_read_sensitive', false) === false) {
+            $deployment->makeHidden([
+                'logs',
+            ]);
         }
 
-        $deployment->makeHidden([
-            'logs',
-        ]);
-
         return serializeApiResponse($deployment);
     }
 
@@ -292,7 +289,7 @@ public function deploy_resource($resource, bool $force = false): array
             return ['message' => "Resource ($resource) not found.", 'deployment_uuid' => $deployment_uuid];
         }
         switch ($resource?->getMorphClass()) {
-            case 'App\Models\Application':
+            case \App\Models\Application::class:
                 $deployment_uuid = new Cuid2;
                 queue_application_deployment(
                     application: $resource,
@@ -301,7 +298,7 @@ public function deploy_resource($resource, bool $force = false): array
                 );
                 $message = "Application {$resource->name} deployment queued.";
                 break;
-            case 'App\Models\Service':
+            case \App\Models\Service::class:
                 StartService::run($resource);
                 $message = "Service {$resource->name} started. It could take a while, be patient.";
                 break;

app/Http/Controllers/Api/OtherController.php

@@ -37,7 +37,7 @@ class OtherController extends Controller
     )]
     public function version(Request $request)
     {
-        return response(config('version'));
+        return response(config('constants.coolify.version'));
     }
 
     #[OA\Get(
@@ -147,7 +147,7 @@ public function disable_api(Request $request)
     public function feedback(Request $request)
     {
         $content = $request->input('content');
-        $webhook_url = config('coolify.feedback_discord_webhook');
+        $webhook_url = config('constants.webhooks.feedback_discord_webhook');
         if ($webhook_url) {
             Http::post($webhook_url, [
                 'content' => $content,
@@ -160,7 +160,7 @@ public function feedback(Request $request)
     #[OA\Get(
         summary: 'Healthcheck',
         description: 'Healthcheck endpoint.',
-        path: '/healthcheck',
+        path: '/health',
         operationId: 'healthcheck',
         responses: [
             new OA\Response(

app/Http/Controllers/Api/ProjectController.php

@@ -116,7 +116,7 @@ public function project_by_uuid(Request $request)
         responses: [
             new OA\Response(
                 response: 200,
-                description: 'Project details',
+                description: 'Environment details',
                 content: new OA\JsonContent(ref: '#/components/schemas/Environment')),
             new OA\Response(
                 response: 401,
@@ -356,7 +356,6 @@ public function update_project(Request $request)
             'name' => $project->name,
             'description' => $project->description,
         ])->setStatusCode(201);
-
     }
 
     #[OA\Delete(
@@ -423,7 +422,7 @@ public function delete_project(Request $request)
         if (! $project) {
             return response()->json(['message' => 'Project not found.'], 404);
         }
-        if ($project->resource_count() > 0) {
+        if (! $project->isEmpty()) {
             return response()->json(['message' => 'Project has resources, so it cannot be deleted.'], 400);
         }
 

app/Http/Controllers/Api/ResourcesController.php

@@ -53,7 +53,7 @@ public function resources(Request $request)
         $resources = $resources->flatten();
         $resources = $resources->map(function ($resource) {
             $payload = $resource->toArray();
-            if ($resource->getMorphClass() === 'App\Models\Service') {
+            if ($resource->getMorphClass() === \App\Models\Service::class) {
                 $payload['status'] = $resource->status();
             } else {
                 $payload['status'] = $resource->status;

app/Http/Controllers/Api/SecurityController.php

@@ -11,13 +11,11 @@ class SecurityController extends Controller
 {
     private function removeSensitiveData($team)
     {
-        $token = auth()->user()->currentAccessToken();
-        if ($token->can('view:sensitive')) {
-            return serializeApiResponse($team);
+        if (request()->attributes->get('can_read_sensitive', false) === false) {
+            $team->makeHidden([
+                'private_key',
+            ]);
         }
-        $team->makeHidden([
-            'private_key',
-        ]);
 
         return serializeApiResponse($team);
     }
@@ -81,15 +79,8 @@ public function keys(Request $request)
             new OA\Response(
                 response: 200,
                 description: 'Get all private keys.',
-                content: [
-                    new OA\MediaType(
-                        mediaType: 'application/json',
-                        schema: new OA\Schema(
-                            type: 'array',
-                            items: new OA\Items(ref: '#/components/schemas/PrivateKey')
-                        )
-                    ),
-                ]),
+                content: new OA\JsonContent(ref: '#/components/schemas/PrivateKey')
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',

app/Http/Controllers/Api/ServersController.php

@@ -2,6 +2,7 @@
 
 namespace App\Http\Controllers\Api;
 
+use App\Actions\Server\DeleteServer;
 use App\Actions\Server\ValidateServer;
 use App\Enums\ProxyStatus;
 use App\Enums\ProxyTypes;
@@ -18,25 +19,22 @@ class ServersController extends Controller
 {
     private function removeSensitiveDataFromSettings($settings)
     {
-        $token = auth()->user()->currentAccessToken();
-        if ($token->can('view:sensitive')) {
-            return serializeApiResponse($settings);
+        if (request()->attributes->get('can_read_sensitive', false) === false) {
+            $settings = $settings->makeHidden([
+                'sentinel_token',
+            ]);
         }
-        $settings = $settings->makeHidden([
-            'metrics_token',
-        ]);
 
         return serializeApiResponse($settings);
     }
 
     private function removeSensitiveData($server)
     {
-        $token = auth()->user()->currentAccessToken();
         $server->makeHidden([
             'id',
         ]);
-        if ($token->can('view:sensitive')) {
-            return serializeApiResponse($server);
+        if (request()->attributes->get('can_read_sensitive', false) === false) {
+            // Do nothing
         }
 
         return serializeApiResponse($server);
@@ -248,7 +246,6 @@ public function resources_by_server(Request $request)
             return $payload;
         });
         $server = $this->removeSensitiveData($server);
-        ray($server);
 
         return response()->json(serializeApiResponse(data_get($server, 'resources')));
     }
@@ -426,6 +423,7 @@ public function domains_by_server(Request $request)
                         'private_key_uuid' => ['type' => 'string', 'example' => 'og888os', 'description' => 'The UUID of the private key.'],
                         'is_build_server' => ['type' => 'boolean', 'example' => false, 'description' => 'Is build server.'],
                         'instant_validate' => ['type' => 'boolean', 'example' => false, 'description' => 'Instant validate.'],
+                        'proxy_type' => ['type' => 'string', 'enum' => ['traefik', 'caddy', 'none'], 'example' => 'traefik', 'description' => 'The proxy type.'],
                     ],
                 ),
             ),
@@ -461,7 +459,7 @@ public function domains_by_server(Request $request)
     )]
     public function create_server(Request $request)
     {
-        $allowedFields = ['name', 'description', 'ip', 'port', 'user', 'private_key_uuid', 'is_build_server', 'instant_validate'];
+        $allowedFields = ['name', 'description', 'ip', 'port', 'user', 'private_key_uuid', 'is_build_server', 'instant_validate', 'proxy_type'];
 
         $teamId = getTeamIdFromToken();
         if (is_null($teamId)) {
@@ -481,6 +479,7 @@ public function create_server(Request $request)
             'user' => 'string|nullable',
             'is_build_server' => 'boolean|nullable',
             'instant_validate' => 'boolean|nullable',
+            'proxy_type' => 'string|nullable',
         ]);
 
         $extraFields = array_diff(array_keys($request->all()), $allowedFields);
@@ -512,6 +511,14 @@ public function create_server(Request $request)
         if (is_null($request->instant_validate)) {
             $request->offsetSet('instant_validate', false);
         }
+        if ($request->proxy_type) {
+            $validProxyTypes = collect(ProxyTypes::cases())->map(function ($proxyType) {
+                return str($proxyType->value)->lower();
+            });
+            if (! $validProxyTypes->contains(str($request->proxy_type)->lower())) {
+                return response()->json(['message' => 'Invalid proxy type.'], 422);
+            }
+        }
         $privateKey = PrivateKey::whereTeamId($teamId)->whereUuid($request->private_key_uuid)->first();
         if (! $privateKey) {
             return response()->json(['message' => 'Private key not found.'], 404);
@@ -521,6 +528,8 @@ public function create_server(Request $request)
             return response()->json(['message' => 'Server with this IP already exists.'], 400);
         }
 
+        $proxyType = $request->proxy_type ? str($request->proxy_type)->upper() : ProxyTypes::TRAEFIK->value;
+
         $server = ModelsServer::create([
             'name' => $request->name,
             'description' => $request->description,
@@ -530,7 +539,7 @@ public function create_server(Request $request)
             'private_key_id' => $privateKey->id,
             'team_id' => $teamId,
             'proxy' => [
-                'type' => ProxyTypes::TRAEFIK->value,
+                'type' => $proxyType,
                 'status' => ProxyStatus::EXITED->value,
             ],
         ]);
@@ -555,6 +564,9 @@ public function create_server(Request $request)
             ['bearerAuth' => []],
         ],
         tags: ['Servers'],
+        parameters: [
+            new OA\Parameter(name: 'uuid', in: 'path', required: true, description: 'Server UUID', schema: new OA\Schema(type: 'string')),
+        ],
         requestBody: new OA\RequestBody(
             required: true,
             description: 'Server updated.',
@@ -571,6 +583,7 @@ public function create_server(Request $request)
                         'private_key_uuid' => ['type' => 'string', 'description' => 'The UUID of the private key.'],
                         'is_build_server' => ['type' => 'boolean', 'description' => 'Is build server.'],
                         'instant_validate' => ['type' => 'boolean', 'description' => 'Instant validate.'],
+                        'proxy_type' => ['type' => 'string', 'enum' => ['traefik', 'caddy', 'none'], 'description' => 'The proxy type.'],
                     ],
                 ),
             ),
@@ -583,8 +596,7 @@ public function create_server(Request $request)
                     new OA\MediaType(
                         mediaType: 'application/json',
                         schema: new OA\Schema(
-                            type: 'array',
-                            items: new OA\Items(ref: '#/components/schemas/Server')
+                            ref: '#/components/schemas/Server'
                         )
                     ),
                 ]),
@@ -604,7 +616,7 @@ public function create_server(Request $request)
     )]
     public function update_server(Request $request)
     {
-        $allowedFields = ['name', 'description', 'ip', 'port', 'user', 'private_key_uuid', 'is_build_server', 'instant_validate'];
+        $allowedFields = ['name', 'description', 'ip', 'port', 'user', 'private_key_uuid', 'is_build_server', 'instant_validate', 'proxy_type'];
 
         $teamId = getTeamIdFromToken();
         if (is_null($teamId)) {
@@ -624,6 +636,7 @@ public function update_server(Request $request)
             'user' => 'string|nullable',
             'is_build_server' => 'boolean|nullable',
             'instant_validate' => 'boolean|nullable',
+            'proxy_type' => 'string|nullable',
         ]);
 
         $extraFields = array_diff(array_keys($request->all()), $allowedFields);
@@ -644,6 +657,16 @@ public function update_server(Request $request)
         if (! $server) {
             return response()->json(['message' => 'Server not found.'], 404);
         }
+        if ($request->proxy_type) {
+            $validProxyTypes = collect(ProxyTypes::cases())->map(function ($proxyType) {
+                return str($proxyType->value)->lower();
+            });
+            if ($validProxyTypes->contains(str($request->proxy_type)->lower())) {
+                $server->changeProxy($request->proxy_type, async: true);
+            } else {
+                return response()->json(['message' => 'Invalid proxy type.'], 422);
+            }
+        }
         $server->update($request->only(['name', 'description', 'ip', 'port', 'user']));
         if ($request->is_build_server) {
             $server->settings()->update([
@@ -654,7 +677,9 @@ public function update_server(Request $request)
             ValidateServer::dispatch($server);
         }
 
-        return response()->json(serializeApiResponse($server))->setStatusCode(201);
+        return response()->json([
+            'uuid' => $server->uuid,
+        ])->setStatusCode(201);
     }
 
     #[OA\Delete(
@@ -726,6 +751,7 @@ public function delete_server(Request $request)
             return response()->json(['message' => 'Server has resources, so you need to delete them before.'], 400);
         }
         $server->delete();
+        DeleteServer::dispatch($server);
 
         return response()->json(['message' => 'Server deleted.']);
     }

app/Http/Controllers/Api/ServicesController.php

@@ -18,19 +18,16 @@ class ServicesController extends Controller
 {
     private function removeSensitiveData($service)
     {
-        $token = auth()->user()->currentAccessToken();
         $service->makeHidden([
             'id',
         ]);
-        if ($token->can('view:sensitive')) {
-            return serializeApiResponse($service);
+        if (request()->attributes->get('can_read_sensitive', false) === false) {
+            $service->makeHidden([
+                'docker_compose_raw',
+                'docker_compose',
+            ]);
         }
 
-        $service->makeHidden([
-            'docker_compose_raw',
-            'docker_compose',
-        ]);
-
         return serializeApiResponse($service);
     }
 
@@ -566,9 +563,8 @@ public function envs(Request $request)
                 'standalone_postgresql_id',
                 'standalone_redis_id',
             ]);
-            $env = $this->removeSensitiveData($env);
 
-            return $env;
+            return $this->removeSensitiveData($env);
         });
 
         return response()->json($envs);
@@ -1238,6 +1234,5 @@ public function action_restart(Request $request)
             ],
             200
         );
-
     }
 }

app/Http/Controllers/Api/TeamController.php

@@ -10,20 +10,18 @@ class TeamController extends Controller
 {
     private function removeSensitiveData($team)
     {
-        $token = auth()->user()->currentAccessToken();
         $team->makeHidden([
             'custom_server_limit',
             'pivot',
         ]);
-        if ($token->can('view:sensitive')) {
-            return serializeApiResponse($team);
+        if (request()->attributes->get('can_read_sensitive', false) === false) {
+            $team->makeHidden([
+                'smtp_username',
+                'smtp_password',
+                'resend_api_key',
+                'telegram_token',
+            ]);
         }
-        $team->makeHidden([
-            'smtp_username',
-            'smtp_password',
-            'resend_api_key',
-            'telegram_token',
-        ]);
 
         return serializeApiResponse($team);
     }