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 @@ curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
 ```
 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 @@ Special thanks to our biggest sponsors!
 
 ### 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 thanks to our biggest 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 @@ Special thanks to our biggest sponsors!
 <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 @@ By subscribing to the cloud version, you get the Coolify server for the same pri
 - Better support
 - Less maintenance for you
 
-
 # Recognitions
 
 <p>
@@ -138,6 +145,13 @@ By subscribing to the cloud version, you get the Coolify server for the same pri
 
 <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 @@ This guide outlines the release process for Coolify, intended for developers and
    - 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 @@ This guide outlines the release process for Coolify, intended for developers and
   <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 @@ This guide outlines the release process for Coolify, intended for developers and
   - 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 @@ This guide outlines the release process for Coolify, intended for developers and
   - **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 @@ When a new version is released and a new GitHub release is created, it doesn't i
 > [!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 @@
 
 ## 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 @@ class StopApplication
             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 @@ class StopApplication
                 CleanupDocker::dispatch($server, true);
             }
         } catch (\Exception $e) {
-            ray($e->getMessage());
-
             return $e->getMessage();
         }
     }

app/Actions/Application/StopApplicationOneServer.php

@@ -32,8 +32,6 @@ class StopApplicationOneServer
                 }
             }
         } 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 @@ class PrepareCoolifyTask
             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\Jobs\ApplicationDeploymentJob;
 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 @@ class RunRemoteProcess
                     ]));
                 }
             } catch (\Throwable $e) {
-                ray($e);
+                Log::error('Error calling event: '.$e->getMessage());
             }
         }
 

app/Actions/Database/StartClickhouse.php

@@ -24,7 +24,7 @@ class StartClickhouse
         $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 @@ class StartClickhouse
                     ],
                     '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 @@ class StartClickhouse
         }
 
         // 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 @@ class StartDatabase
             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 @@ class StartDatabaseProxy
         $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 @@ class StartDatabaseProxy
             $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 @@ class StartDragonfly
         $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 @@ class StartDragonfly
                     ],
                     '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 @@ class StartDragonfly
         }
 
         // 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 @@ class StartKeydb
         $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 @@ class StartKeydb
                     ],
                     '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 @@ class StartKeydb
         }
 
         // 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 @@ class StartMariadb
         $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 @@ class StartMariadb
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => ['CMD', 'healthcheck.sh', '--connect', '--innodb_initialized'],
@@ -99,8 +101,8 @@ class StartMariadb
         }
 
         // 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 @@ class StartMongodb
         $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 @@ class StartMongodb
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => [
@@ -115,8 +121,8 @@ class StartMongodb
         ];
 
         // 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 @@ class StartMysql
         $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 @@ class StartMysql
                     ],
                     '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 @@ class StartMysql
         }
 
         // 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 @@ class StartPostgresql
         $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 @@ class StartPostgresql
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => [
@@ -120,8 +122,8 @@ class StartPostgresql
             ];
         }
         // 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 @@ class StartRedis
     {
         $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 @@ class StartRedis
         $environment_variables = $this->generate_environment_variables();
         $this->add_custom_redis();
 
+        $startCommand = $this->buildStartCommand();
+
         $docker_compose = [
             'services' => [
                 $container_name => [
@@ -50,6 +50,8 @@ class StartRedis
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => [
@@ -105,12 +107,11 @@ class StartRedis
                 '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 @@ class StartRedis
     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 @@ class StartRedis
         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 @@ class GetContainersStatus
         $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 @@ class GetContainersStatus
         $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 @@ class GetContainersStatus
                         $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 @@ class GetContainersStatus
                         $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 @@ class GetContainersStatus
                             $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 @@ class GetContainersStatus
                                 })->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 @@ class GetContainersStatus
                     if ($statusFromDb !== $containerStatus) {
                         // ray('Updating status: ' . $containerStatus);
                         $service->update(['status' => $containerStatus]);
+                    } else {
+                        $service->update(['last_online_at' => now()]);
                     }
                 }
             }
@@ -650,32 +342,5 @@ class GetContainersStatus
             }
             // $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 App\Models\User;
 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 @@ class CreateNewUser implements CreatesNewUsers
                 'max:255',
                 Rule::unique(User::class),
             ],
-            'password' => $this->passwordRules(),
+            'password' => ['required', Password::defaults(), 'confirmed'],
         ])->validate();
 
         if (User::count() == 0) {
@@ -41,7 +40,7 @@ class CreateNewUser implements CreatesNewUsers
             $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 @@ class CreateNewUser implements CreatesNewUsers
         } 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 @@ namespace App\Actions\Fortify;
 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 @@ namespace App\Actions\Fortify;
 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 @@ class UpdateUserPassword implements UpdatesUserPasswords
     {
         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 @@ namespace App\Actions\Proxy;
 
 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 @@ class CheckProxy
         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 @@ class CheckProxy
                     $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 @@ class ConfigureCloudflared
             ]);
             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 @@ class ConfigureCloudflared
                 '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 @@ namespace App\Actions\Server;
 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 @@ services:
       - ./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 @@ Files:
 ');
             $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 @@ Files:
                 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 @@ namespace App\Actions\Server;
 
 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 @@ namespace App\Actions\Service;
 
 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 @@ class DeleteService
                 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 @@ class StartService
                 $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 @@ class StopService
                 }
             }
         } catch (\Exception $e) {
-            ray($e->getMessage());
-
             return $e->getMessage();
         }
     }

app/Console/Commands/CleanupDatabase.php

@@ -7,7 +7,7 @@ use Illuminate\Support\Facades\DB;
 
 class CleanupDatabase extends Command
 {
-    protected $signature = 'cleanup:database {--yes}';
+    protected $signature = 'cleanup:database {--yes} {--keep-days=}';
 
     protected $description = 'Cleanup database';
 
@@ -20,9 +20,9 @@ class CleanupDatabase extends Command
         }
         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 @@ class CleanupDatabase extends Command
         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 @@ class CleanupRedis extends Command
         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 @@ class CleanupUnreachableServers extends Command
         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 @@ class CloudCleanupSubscriptions extends Command
 
                 return;
             }
-            ray()->clearAll();
             $this->info('Cleaning up subcriptions teams');
             $stripe = new \Stripe\StripeClient(config('subscription.stripe_api_key'));
 
@@ -37,7 +36,7 @@ class CloudCleanupSubscriptions extends Command
                 }
                 // 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 @@ class CloudCleanupSubscriptions extends Command
                     $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 @@ class CloudCleanupSubscriptions extends Command
                     }
                 }
             }
-
         } catch (\Exception $e) {
             $this->error($e->getMessage());
 
@@ -96,6 +94,5 @@ class CloudCleanupSubscriptions extends Command
                 ]);
             }
         }
-
     }
 }

app/Console/Commands/Dev.php

@@ -6,6 +6,7 @@ use App\Models\InstanceSettings;
 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 @@ class Dev extends Command
 
             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 @@ class Dev extends Command
         } 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 @@ class Emails extends Command
                 '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 @@ class Emails extends Command
                 $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 @@ class Emails extends Command
                         '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 @@ class Emails extends Command
                 //     $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 @@ class Init extends Command
 
         $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 @@ class Init extends Command
             $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 @@ class Init extends Command
                 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 @@ class Init extends Command
         }
     }
 
-    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 @@ class Init extends Command
             } catch (\Throwable $e) {
                 echo "Error in cleaning up unnecessary dynamic proxy configuration: {$e->getMessage()}\n";
             }
-
         }
     }
 
@@ -155,7 +186,6 @@ class Init extends Command
                     }
                 }
                 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 @@ class Init extends Command
 
     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 @@ class Init extends Command
                             '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 @@ class Init extends Command
     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 @@ class Init extends Command
             }
             $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 @@ class Init extends Command
 
     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 @@ class NotifyDemo extends Command
 
             return;
         }
-
-        ray($channel);
     }
 
     private function showHelp()

app/Console/Commands/OpenApi.php

@@ -15,12 +15,19 @@ class OpenApi extends Command
     {
         // 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 @@ class SyncBunny extends Command
 
         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 @@ class SyncBunny extends Command
         });
         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 @@ class Kernel extends ConsoleKernel
 
             $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 @@ class Kernel extends ConsoleKernel
             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\Broadcasting\PrivateChannel;
 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\Broadcasting\PrivateChannel;
 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 @@ class Handler extends ExceptionHandler
             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 @@ class SshMultiplexingHelper
         ];
     }
 
-    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 @@ class SshMultiplexingHelper
         $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 @@ class SshMultiplexingHelper
         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 @@ class SshMultiplexingHelper
         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 @@ class SshMultiplexingHelper
 
         $sshConfig = self::serverSshConfiguration($server);
         $sshKeyLocation = $sshConfig['sshKeyLocation'];
+
+        self::validateSshKey($server->privateKey);
+
         $muxSocket = $sshConfig['muxFilename'];
 
         $timeout = config('constants.ssh.command_timeout');
@@ -127,9 +126,8 @@ class SshMultiplexingHelper
 
         $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 @@ class SshMultiplexingHelper
 
     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 @@ class ApplicationsController extends Controller
                             items: new OA\Items(ref: '#/components/schemas/Application')
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -180,8 +179,10 @@ class ApplicationsController extends Controller
                             '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 @@ class ApplicationsController extends Controller
                             '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 @@ class ApplicationsController extends Controller
                             '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 @@ class ApplicationsController extends Controller
                             '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 @@ class ApplicationsController extends Controller
                             '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 @@ class ApplicationsController extends Controller
                             '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 @@ class ApplicationsController extends Controller
 
     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 @@ class ApplicationsController extends Controller
         $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 @@ class ApplicationsController extends Controller
         }
 
         return response()->json(['message' => 'Invalid type.'], 400);
-
     }
 
     #[OA\Get(
@@ -1248,7 +1279,8 @@ class ApplicationsController extends Controller
                             ref: '#/components/schemas/Application'
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1320,7 +1352,8 @@ class ApplicationsController extends Controller
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1446,8 +1479,10 @@ class ApplicationsController extends Controller
                             '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 @@ class ApplicationsController extends Controller
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1501,7 +1537,7 @@ class ApplicationsController extends Controller
             ], 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 @@ class ApplicationsController extends Controller
             '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 @@ class ApplicationsController extends Controller
                 }
             }
         }
+        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 @@ class ApplicationsController extends Controller
         }
         $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 @@ class ApplicationsController extends Controller
             $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 @@ class ApplicationsController extends Controller
                             items: new OA\Items(ref: '#/components/schemas/EnvironmentVariable')
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1687,9 +1766,8 @@ class ApplicationsController extends Controller
                 'standalone_postgresql_id',
                 'standalone_redis_id',
             ]);
-            $env = $this->removeSensitiveData($env);
 
-            return $env;
+            return $this->removeSensitiveData($env);
         });
 
         return response()->json($envs);
@@ -1752,7 +1830,8 @@ class ApplicationsController extends Controller
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1864,18 +1943,15 @@ class ApplicationsController extends Controller
 
                 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 @@ class ApplicationsController extends Controller
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -2124,7 +2201,8 @@ class ApplicationsController extends Controller
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -2220,14 +2298,12 @@ class ApplicationsController extends Controller
                 return response()->json([
                     'uuid' => $env->uuid,
                 ])->setStatusCode(201);
-
             }
         }
 
         return response()->json([
             'message' => 'Something went wrong.',
         ], 500);
-
     }
 
     #[OA\Delete(
@@ -2275,7 +2351,8 @@ class ApplicationsController extends Controller
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -2367,9 +2444,11 @@ class ApplicationsController extends Controller
                             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 @@ class ApplicationsController extends Controller
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -2529,7 +2609,8 @@ class ApplicationsController extends Controller
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
 
             new OA\Response(
                 response: 401,
@@ -2575,7 +2656,6 @@ class ApplicationsController extends Controller
                 'deployment_uuid' => $deployment_uuid->toString(),
             ],
         );
-
     }
 
     #[OA\Post(
@@ -2741,7 +2821,6 @@ class ApplicationsController extends Controller
                         '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 @@ class DatabasesController extends Controller
                         '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 @@ class DatabasesController extends Controller
     )]
     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 @@ class DatabasesController extends Controller
                 }
                 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 @@ class DatabasesController extends Controller
 
                 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 @@ class DatabasesController extends Controller
                     $request->offsetSet('mysql_conf', $mysqlConf);
                 }
                 break;
-
         }
         $extraFields = array_diff(array_keys($request->all()), $allowedFields);
         if ($validator->fails() || ! empty($extraFields)) {
@@ -506,7 +504,6 @@ class DatabasesController extends Controller
         return response()->json([
             'message' => 'Database updated.',
         ]);
-
     }
 
     #[OA\Post(
@@ -911,6 +908,7 @@ class DatabasesController extends Controller
                         '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 @@ class DatabasesController extends Controller
 
     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 @@ class DatabasesController extends Controller
             }
 
             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 @@ class DatabasesController extends Controller
 
             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 @@ class DatabasesController extends Controller
 
             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 @@ class DatabasesController extends Controller
                             ]
                         )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1635,9 +1634,11 @@ class DatabasesController extends Controller
                             type: 'object',
                             properties: [
                                 'message' => ['type' => 'string', 'example' => 'Database starting request queued.'],
-                            ])
+                            ]
+                        )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1711,9 +1712,11 @@ class DatabasesController extends Controller
                             type: 'object',
                             properties: [
                                 'message' => ['type' => 'string', 'example' => 'Database stopping request queued.'],
-                            ])
+                            ]
+                        )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1787,9 +1790,11 @@ class DatabasesController extends Controller
                             type: 'object',
                             properties: [
                                 'message' => ['type' => 'string', 'example' => 'Database restaring request queued.'],
-                            ])
+                            ]
+                        )
                     ),
-                ]),
+                ]
+            ),
             new OA\Response(
                 response: 401,
                 ref: '#/components/responses/401',
@@ -1826,6 +1831,5 @@ class DatabasesController extends Controller
             ],
             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 @@ class DeployController extends Controller
             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 @@ class DeployController extends Controller
                 );
                 $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 @@ class OtherController extends Controller
     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 @@ class OtherController extends Controller
     #[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 @@ class ProjectController extends Controller
         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 @@ class ProjectController extends Controller
             'name' => $project->name,
             'description' => $project->description,
         ])->setStatusCode(201);
-
     }
 
     #[OA\Delete(
@@ -423,7 +422,7 @@ class ProjectController extends Controller
         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 @@ class ResourcesController extends Controller
         $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 @@ class SecurityController extends Controller
             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 @@ class ServersController extends Controller
             return $payload;
         });
         $server = $this->removeSensitiveData($server);
-        ray($server);
 
         return response()->json(serializeApiResponse(data_get($server, 'resources')));
     }
@@ -426,6 +423,7 @@ class ServersController extends Controller
                         '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 @@ class ServersController extends Controller
     )]
     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 @@ class ServersController extends Controller
             '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 @@ class ServersController extends Controller
         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 @@ class ServersController extends Controller
             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 @@ class ServersController extends Controller
             'private_key_id' => $privateKey->id,
             'team_id' => $teamId,
             'proxy' => [
-                'type' => ProxyTypes::TRAEFIK->value,
+                'type' => $proxyType,
                 'status' => ProxyStatus::EXITED->value,
             ],
         ]);
@@ -555,6 +564,9 @@ class ServersController extends Controller
             ['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 @@ class ServersController extends Controller
                         '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 @@ class ServersController extends Controller
                     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 @@ class ServersController extends Controller
     )]
     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 @@ class ServersController extends Controller
             '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 @@ class ServersController extends Controller
         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 @@ class ServersController extends Controller
             ValidateServer::dispatch($server);
         }
 
-        return response()->json(serializeApiResponse($server))->setStatusCode(201);
+        return response()->json([
+            'uuid' => $server->uuid,
+        ])->setStatusCode(201);
     }
 
     #[OA\Delete(
@@ -726,6 +751,7 @@ class ServersController extends Controller
             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 @@ class ServicesController extends Controller
                 'standalone_postgresql_id',
                 'standalone_redis_id',
             ]);
-            $env = $this->removeSensitiveData($env);
 
-            return $env;
+            return $this->removeSensitiveData($env);
         });
 
         return response()->json($envs);
@@ -1238,6 +1234,5 @@ class ServicesController extends Controller
             ],
             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);
     }