fix: select server view

v4.0.0-beta.356

.env.development.example

@@ -1,16 +1,34 @@
-APP_NAME=Coolify-localhost
-APP_ID=development
+# Coolify Configuration
 APP_ENV=local
+APP_NAME="Coolify Development"
+APP_ID=development
 APP_KEY=
-APP_DEBUG=true
 APP_URL=http://localhost
 APP_PORT=8000
-MUX_ENABLED=false
+APP_DEBUG=true
+SSH_MUX_ENABLED=true
 
+# PostgreSQL Database Configuration
+DB_DATABASE=coolify
+DB_USERNAME=coolify
+DB_PASSWORD=password
+DB_HOST=host.docker.internal
+DB_PORT=5432
+
+# Ray Configuration
+# Set to true to enable Ray
+RAY_ENABLED=false
+# Set custom ray port
+# RAY_PORT=
+
+# Enable Laravel Telescope for debugging
+TELESCOPE_ENABLED=false
+
+# Selenium Driver URL for Dusk
 DUSK_DRIVER_URL=http://selenium:4444
 
-## For Andras only
-# To purge cache
+# Special Keys for Andras
+# For cache purging
 BUNNY_API_KEY=
-# To upload assets
+# For asset uploads
 BUNNY_STORAGE_API_KEY=

.env.production

@@ -1,10 +1,16 @@
+# Coolify Configuration
 APP_ID=
 APP_NAME=Coolify
 APP_KEY=
 
+# PostgreSQL Database Configuration
+DB_USERNAME=coolify
 DB_PASSWORD=
+
+# Redis Configuration
 REDIS_PASSWORD=
 
+# Pusher Configuration
 PUSHER_APP_ID=
 PUSHER_APP_KEY=
 PUSHER_APP_SECRET=

.github/ISSUE_TEMPLATE/01_BUG_REPORT.yml

@@ -0,0 +1,65 @@
+name: 🐞 Bug Report
+description: "File a new bug report."
+title: "[Bug]: "
+labels: ["🐛 Bug", "🔍 Triage"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        > [!IMPORTANT]
+        > **Please ensure you are using the latest version of Coolify before submitting an issue, as the bug may have already been fixed in a recent update.** (Of course, if you're experiencing an issue on the latest version that wasn't present in a previous version, please let us know.)
+
+        # 💎 Bounty Program (with [algora.io](https://console.algora.io/org/coollabsio/bounties/new))
+          - If you would like to prioritize the issue resolution, consider adding a bounty to this issue through our [Bounty Program](https://console.algora.io/org/coollabsio/bounties/new).
+
+  - type: textarea
+    attributes:
+      label: Error Message and Logs
+      description: Provide a detailed description of the error or exception you encountered, along with any relevant log output.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Steps to Reproduce
+      description: Please provide a step-by-step guide to reproduce the issue. Be as detailed as possible, otherwise we may not be able to assist you.
+      value: |
+        1.
+        2.
+        3.
+        4.
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: Example Repository URL
+      description: If applicable, provide a URL to a repository demonstrating the issue.
+
+  - type: input
+    attributes:
+      label: Coolify Version
+      description: Please provide the Coolify version you are using. This can be found in the top left corner of your Coolify dashboard.
+      placeholder: "v4.0.0-beta.335"
+    validations:
+      required: true
+
+  - type: dropdown
+    attributes:
+      label: Are you using Coolify Cloud?
+      options:
+        - "No (self-hosted)"
+        - "Yes (Coolify Cloud)"
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: Operating System and Version (self-hosted)
+      description: Run `cat /etc/os-release` or `lsb_release -a` in your terminal and provide the operating system and version.
+      placeholder: "Ubuntu 22.04"
+
+  - type: textarea
+    attributes:
+      label: Additional Information
+      description: Any other relevant details about the issue.

.github/ISSUE_TEMPLATE/02_ENHANCEMENT_BOUNTY.yml

@@ -0,0 +1,31 @@
+name: 💎 Enhancement Bounty
+description: "Propose a new feature, service, or improvement with an attached bounty."
+title: "[Enhancement]: "
+labels: ["✨ Enhancement", "🔍 Triage"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        > [!IMPORTANT]
+        > **This issue template is exclusively for proposing new features, services, or improvements with an attached bounty.** Enhancements without a bounty can be discussed in the appropriate category of [Github Discussions](https://github.com/coollabsio/coolify/discussions).
+
+        # 💎 Add a Bounty (with [algora.io](https://console.algora.io/org/coollabsio/bounties/new))
+          - [Click here to add the required bounty](https://console.algora.io/org/coollabsio/bounties/new)
+
+  - type: dropdown
+    attributes:
+      label: Request Type
+      description: Select the type of request you are making.
+      options:
+        - New Feature
+        - New Service
+        - Improvement
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Description
+      description: Provide a detailed description of the feature, improvement, or service you are proposing.
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/BUG_REPORT.yml

@@ -1,37 +0,0 @@
-name: Bug report
-description: 'Create a new bug report.'
-title: '[Bug]: '
-body:
-  - type: markdown
-    attributes:
-      value: >-
-        # 💎 Bounty program (with
-        [algora.io](https://console.algora.io/org/coollabsio/bounties/new))
-
-
-        If you would like to prioritize the issue resolution, you can add bounty
-        to this issue.
-
-
-        Click [here](https://console.algora.io/org/coollabsio/bounties/new) to
-        get started.
-  - type: textarea
-    attributes:
-      label: Description
-      description: A clear and concise description of the problem
-  - type: textarea
-    attributes:
-      label: Minimal Reproduction (if possible, example repository)
-      description: Please provide a step by step guide to reproduce the issue.
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Exception or Error
-      description: Please provide error logs if possible.
-  - type: input
-    attributes:
-      label: Version
-      description: Coolify's version (see top of your screen).
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1,18 @@
 blank_issues_enabled: false
+
 contact_links:
-  - name: 🤔 Community Support (Chat)
+  - name: 🤔 Questions and Community Support
     url: https://coollabs.io/discord
-    about: Reach out to us on Discord.
-  - name: 🙋‍♂️ Feature Requests
-    url: https://github.com/coollabsio/coolify/discussions/categories/feature-requests-ideas
-    about: All feature requests will be discussed here.
+    about: If you have any questions, reach out to us on Discord inside the "#support" channel.
+
+  - name: 💡 Feature Request
+    url: https://github.com/coollabsio/coolify/discussions/categories/feature-requests
+    about: Suggest a new feature for Coolify.
+
+  - name: ⚙️ Service Request
+    url: https://github.com/coollabsio/coolify/discussions/categories/service-requests
+    about: Request a new service integration for Coolify.
+
+  - name: 🔧 Improvements
+    url: https://github.com/coollabsio/coolify/discussions/categories/improvements
+    about: Suggest improvements to existing features for Coolify.

.github/pull_request_template.md

@@ -1 +1,13 @@
-> Always use `next` branch as destination branch for PRs, not `main`
+## Submit Checklist (REMOVE THIS SECTION BEFORE SUBMITTING)
+- [ ] I have selected the `next` branch as the destination for my PR, not `main`.
+- [ ] I have listed all changes in the `Changes` section.
+- [ ] I have filled out the `Issues` section with the issue/discussion link(s) (if applicable).
+- [ ] I have tested my changes.
+- [ ] I have considered backwards compatibility.
+- [ ] I have removed this checklist and any unused sections.
+
+## Changes
+- 
+
+## Issues
+- fix #

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

@@ -25,6 +25,10 @@ jobs:
           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 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
         with:
@@ -33,7 +37,9 @@ jobs:
           file: docker/coolify-helper/Dockerfile
           platforms: linux/amd64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:next
+          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
+          labels: |
+            coolify.managed=true
   aarch64:
     runs-on: [ self-hosted, arm64 ]
     permissions:
@@ -47,6 +53,10 @@ jobs:
           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 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
         with:
@@ -55,7 +65,9 @@ jobs:
           file: docker/coolify-helper/Dockerfile
           platforms: linux/aarch64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:next-aarch64
+          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
+          labels: |
+            coolify.managed=true
   merge-manifest:
     runs-on: ubuntu-latest
     permissions:
@@ -75,10 +87,15 @@ jobs:
           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 ghcr.io/jqlang/jq:latest '.coolify.helper.version' versions.json)"|xargs >> $GITHUB_OUTPUT
       - name: Create & publish manifest
         run: |
-          docker buildx imagetools create --append ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:next-aarch64 --tag ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:next
+          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
       - uses: sarisia/actions-status-discord@v1
         if: always()
         with:
           webhook: ${{ secrets.DISCORD_WEBHOOK_DEV_RELEASE_CHANNEL  }}
+

.github/workflows/coolify-helper.yml

@@ -25,6 +25,10 @@ jobs:
           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 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
         with:
@@ -33,7 +37,9 @@ jobs:
           file: docker/coolify-helper/Dockerfile
           platforms: linux/amd64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
+          labels: |
+            coolify.managed=true
   aarch64:
     runs-on: [ self-hosted, arm64 ]
     permissions:
@@ -47,6 +53,10 @@ jobs:
           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 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
         with:
@@ -55,7 +65,9 @@ jobs:
           file: docker/coolify-helper/Dockerfile
           platforms: linux/aarch64
           push: true
-          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64
+          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
+          labels: |
+            coolify.managed=true
   merge-manifest:
     runs-on: ubuntu-latest
     permissions:
@@ -75,10 +87,15 @@ jobs:
           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 ghcr.io/jqlang/jq:latest '.coolify.helper.version' versions.json)"|xargs >> $GITHUB_OUTPUT
       - name: Create & publish manifest
         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.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  }}
+

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

@@ -0,0 +1,103 @@
+name: Coolify Realtime Development (v4)
+
+on:
+  push:
+    branches: [ "next" ]
+    paths:
+      - .github/workflows/coolify-realtime.yml
+      - docker/coolify-realtime/Dockerfile
+      - docker/coolify-realtime/terminal-server.js
+      - docker/coolify-realtime/package.json
+      - docker/coolify-realtime/soketi-entrypoint.sh
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: "coollabsio/coolify-realtime"
+
+jobs:
+  amd64:
+    runs-on: ubuntu-latest
+    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: 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
+        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
+          labels: |
+            coolify.managed=true
+  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: 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
+        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
+          labels: |
+            coolify.managed=true
+  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 ghcr.io/jqlang/jq:latest '.coolify.realtime.version' versions.json)"|xargs >> $GITHUB_OUTPUT
+      - name: Create & publish manifest
+        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
+      - uses: sarisia/actions-status-discord@v1
+        if: always()
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK_PROD_RELEASE_CHANNEL  }}

.github/workflows/coolify-realtime.yml

@@ -0,0 +1,103 @@
+name: Coolify Realtime (v4)
+
+on:
+  push:
+    branches: [ "main" ]
+    paths:
+      - .github/workflows/coolify-realtime.yml
+      - docker/coolify-realtime/Dockerfile
+      - docker/coolify-realtime/terminal-server.js
+      - docker/coolify-realtime/package.json
+      - docker/coolify-realtime/soketi-entrypoint.sh
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: "coollabsio/coolify-realtime"
+
+jobs:
+  amd64:
+    runs-on: ubuntu-latest
+    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: 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
+        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 }}
+          labels: |
+            coolify.managed=true
+  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: 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
+        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
+          labels: |
+            coolify.managed=true
+  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 ghcr.io/jqlang/jq:latest '.coolify.realtime.version' versions.json)"|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  }}

.github/workflows/docker-image.yml

@@ -1,44 +0,0 @@
-name: Docker Image CI
-
-on:
-  # push:
-  #   branches: [ "main" ]
-  # pull_request:
-  #   branches: [ "*" ]
-  push:
-    branches: ["this-does-not-exist"]
-  pull_request:
-    branches: ["this-does-not-exist"]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Cache Docker layers
-        uses: actions/cache@v2
-        with:
-          path: |
-            /usr/local/share/ca-certificates
-            /var/cache/apt/archives
-            /var/lib/apt/lists
-            ~/.cache
-          key: ${{ runner.os }}-docker-${{ hashFiles('**/Dockerfile') }}
-          restore-keys: |
-            ${{ runner.os }}-docker-
-      - name: Build the Docker image
-        run: |
-          cp .env.example .env
-          docker run --rm -u "$(id -u):$(id -g)" \
-            -v "$(pwd):/app" \
-            -w /app composer:2 \
-            composer install --ignore-platform-reqs
-          ./vendor/bin/spin build
-      - name: Start the stack
-        run: |
-          ./vendor/bin/spin up -d
-          ./vendor/bin/spin exec coolify php artisan key:generate
-          ./vendor/bin/spin exec coolify php artisan migrate:fresh --seed
-      - name: Test (missing E2E tests)
-        run: |
-          ./vendor/bin/spin exec coolify php artisan test

.github/workflows/lock-closed-issues-discussions-and-prs.yml

@@ -0,0 +1,17 @@
+name: Lock closed Issues, Discussions, and PRs
+
+on:
+  schedule:
+    - cron: '0 1 * * *'
+
+jobs:
+  lock-threads:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Lock threads after 30 days of inactivity
+        uses: dessant/lock-threads@v5
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          issue-inactive-days: '30'
+          pr-inactive-days: '30'
+          discussion-inactive-days: '30'

.github/workflows/manage-stale-issues-and-prs.yml

@@ -0,0 +1,28 @@
+name: Manage Stale Issues and PRs
+
+on:
+  schedule:
+    - cron: '0 2 * * *'
+
+jobs:
+  manage-stale:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Manage stale issues and PRs
+        uses: actions/stale@v9
+        id: stale
+        with:
+          stale-issue-message: 'This issue will be automatically closed in a few days if no response is received. Please provide an update with the requested information.'
+          stale-pr-message: 'This pull request will be automatically closed in a few days if no response is received. Please update your PR or comment if you would like to continue working on it.'
+          close-issue-message: 'This issue has been automatically closed due to inactivity.'
+          close-pr-message: 'This pull request has been automatically closed due to inactivity.'
+          days-before-stale: 14
+          days-before-close: 7
+          stale-issue-label: '⏱︎ Stale'
+          stale-pr-label: '⏱︎ Stale'
+          only-labels: '💤 Waiting for feedback'
+          remove-stale-when-updated: true
+          operations-per-run: 100
+          labels-to-remove-when-unstale: '⏱︎ Stale, 💤 Waiting for feedback'
+          close-issue-reason: 'not_planned'
+          exempt-all-milestones: false

.github/workflows/production-build.yml

@@ -4,6 +4,8 @@ on:
   push:
     branches: ["main"]
     paths-ignore:
+      - .github/workflows/coolify-helper.yml
+      - docker/coolify-helper/Dockerfile
       - templates/service-templates.json
 
 env:

.github/workflows/remove-labels-and-assignees-on-close.yml

@@ -0,0 +1,78 @@
+name: Remove Labels and Assignees on Issue Close
+
+on:
+  issues:
+    types: [closed]
+  pull_request:
+    types: [closed]
+  pull_request_target:
+    types: [closed]
+
+jobs:
+  remove-labels-and-assignees:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Remove labels and assignees
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const { owner, repo } = context.repo;
+
+            async function processIssue(issueNumber) {
+              try {
+                const { data: currentLabels } = await github.rest.issues.listLabelsOnIssue({
+                  owner,
+                  repo,
+                  issue_number: issueNumber
+                });
+
+                const labelsToKeep = currentLabels
+                  .filter(label => label.name === '⏱︎ Stale')
+                  .map(label => label.name);
+
+                await github.rest.issues.setLabels({
+                  owner,
+                  repo,
+                  issue_number: issueNumber,
+                  labels: labelsToKeep
+                });
+
+                const { data: issue } = await github.rest.issues.get({
+                  owner,
+                  repo,
+                  issue_number: issueNumber
+                });
+
+                if (issue.assignees && issue.assignees.length > 0) {
+                  await github.rest.issues.removeAssignees({
+                    owner,
+                    repo,
+                    issue_number: issueNumber,
+                    assignees: issue.assignees.map(assignee => assignee.login)
+                  });
+                }
+              } catch (error) {
+                if (error.status !== 404) {
+                  console.error(`Error processing issue ${issueNumber}:`, error);
+                }
+              }
+            }
+
+            if (context.eventName === 'issues' || context.eventName === 'pull_request' || context.eventName === 'pull_request_target') {
+              const issue = context.payload.issue || context.payload.pull_request;
+              await processIssue(issue.number);
+            }
+
+            if (context.eventName === 'pull_request' || context.eventName === 'pull_request_target') {
+              const pr = context.payload.pull_request;
+              if (pr.body) {
+                const issueReferences = pr.body.match(/#(\d+)/g);
+                if (issueReferences) {
+                  for (const reference of issueReferences) {
+                    const issueNumber = parseInt(reference.substring(1));
+                    await processIssue(issueNumber);
+                  }
+                }
+              }
+            }

CONTRIBUTING.md

@@ -0,0 +1,243 @@
+# Contributing to Coolify
+
+> "First, thanks for considering contributing to my project. It really means a lot!" - [@andrasbacsai](https://github.com/andrasbacsai)
+
+You can ask for guidance anytime on our [Discord server](https://coollabs.io/discord) in the `#contribute` channel.
+
+## Table of Contents
+
+1. [Setup Development Environment](#1-setup-development-environment)
+2. [Verify Installation](#2-verify-installation-optional)
+3. [Fork and Setup Local Repository](#3-fork-and-setup-local-repository)
+4. [Set up Environment Variables](#4-set-up-environment-variables)
+5. [Start Coolify](#5-start-coolify)
+6. [Start Development](#6-start-development)
+7. [Create a Pull Request](#7-create-a-pull-request)
+8. [Development Notes](#development-notes)
+9. [Resetting Development Environment](#resetting-development-environment)
+10. [Additional Contribution Guidelines](#additional-contribution-guidelines)
+
+## 1. Setup Development Environment
+
+Follow the steps below for your operating system:
+
+<details>
+<summary><strong>Windows</strong></summary>
+
+1. Install `docker-ce`, Docker Desktop (or similar):
+   - Docker CE (recommended):
+     - Install Windows Subsystem for Linux v2 (WSL2) by following this guide: [Install WSL](https://learn.microsoft.com/en-us/windows/wsl/install?ref=coolify)
+     - After installing WSL2, install Docker CE for your Linux distribution by following this guide: [Install Docker Engine](https://docs.docker.com/engine/install/?ref=coolify)
+     - Make sure to choose the appropriate Linux distribution (e.g., Ubuntu) when following the Docker installation guide
+   - Install Docker Desktop (easier):
+     - Download and install [Docker Desktop for Windows](https://docs.docker.com/desktop/install/windows-install/?ref=coolify)
+     - Ensure WSL2 backend is enabled in Docker Desktop settings
+
+2. Install Spin:
+   - Follow the instructions to install Spin on Windows from the [Spin documentation](https://serversideup.net/open-source/spin/docs/installation/install-windows#download-and-install-spin-into-wsl2?ref=coolify)
+
+</details>
+
+<details>
+<summary><strong>MacOS</strong></summary>
+
+1. Install Orbstack, Docker Desktop (or similar):
+   - Orbstack (recommended, as it is a faster and lighter alternative to Docker Desktop):
+     - Download and install [Orbstack](https://docs.orbstack.dev/quick-start#installation?ref=coolify)
+   - Docker Desktop:
+     - Download and install [Docker Desktop for Mac](https://docs.docker.com/desktop/install/mac-install/?ref=coolify)
+
+2. Install Spin:
+   - Follow the instructions to install Spin on MacOS from the [Spin documentation](https://serversideup.net/open-source/spin/docs/installation/install-macos/#download-and-install-spin?ref=coolify)
+
+</details>
+
+<details>
+<summary><strong>Linux</strong></summary>
+
+1. Install Docker Engine, Docker Desktop (or similar):
+   - Docker Engine (recommended, as there is no VM overhead):
+     - Follow the official [Docker Engine installation guide](https://docs.docker.com/engine/install/?ref=coolify) for your Linux distribution
+   - Docker Desktop:
+     - If you want a GUI, you can use [Docker Desktop for Linux](https://docs.docker.com/desktop/install/linux-install/?ref=coolify)
+
+2. Install Spin:
+   - Follow the instructions to install Spin on Linux from the [Spin documentation](https://serversideup.net/open-source/spin/docs/installation/install-linux#configure-docker-permissions?ref=coolify)
+
+</details>
+
+## 2. Verify Installation (Optional)
+
+After installing Docker (or Orbstack) and Spin, verify the installation:
+
+1. Open a terminal or command prompt
+2. Run the following commands:
+   ```bash
+   docker --version
+   spin --version
+   ```
+   You should see version information for both Docker and Spin.
+
+## 3. Fork and Setup Local Repository
+
+1. Fork the [Coolify](https://github.com/coollabsio/coolify) repository to your GitHub account.
+
+2. Install a code editor on your machine (choose one):
+
+   | Editor | Platform | Download Link |
+   |--------|----------|---------------|
+   | Visual Studio Code (recommended free) | Windows/macOS/Linux | [Download](https://code.visualstudio.com/download?ref=coolify) |
+   | Cursor (recommended but paid) | Windows/macOS/Linux | [Download](https://www.cursor.com/?ref=coolify) |
+   | Zed (very fast) | macOS/Linux | [Download](https://zed.dev/download?ref=coolify) |
+
+3. Clone the Coolify Repository from your fork to your local machine
+   - Use `git clone` in the command line, or
+   - Use GitHub Desktop (recommended):
+     - Download and install from [https://desktop.github.com/](https://desktop.github.com/?ref=coolify)
+     - Open GitHub Desktop and login with your GitHub account
+     - Click on `File` -> `Clone Repository` select `github.com` as the repository location, then select your forked Coolify repository, choose the local path and then click `Clone`
+
+4. Open the cloned Coolify Repository in your chosen code editor.
+
+## 4. Set up Environment Variables
+
+1. In the Code Editor, locate the `.env.development.example` file in the root directory of your local Coolify repository.
+2. Duplicate the `.env.development.example` file and rename the copy to `.env`.
+3. Open the new `.env` file and review its contents. Adjust any environment variables as needed for your development setup.
+4. If you encounter errors during database migrations, update the database connection settings in your `.env` file. Use the IP address or hostname of your PostgreSQL database container. You can find this information by running `docker ps` after executing `spin up`.
+5. Save the changes to your `.env` file.
+
+## 5. Start Coolify
+
+1. Open a terminal in the local Coolify directory.
+2. Run the following command in the terminal (leave that terminal open):
+   ```bash
+   spin up
+   ```
+
+> [!NOTE]
+> You may see some errors, but don't worry; this is expected.
+
+3. If you encounter permission errors, especially on macOS, use:
+   ```bash
+   sudo spin up
+   ```
+
+> [!NOTE]
+> If you change environment variables afterwards or anything seems broken, press Ctrl + C to stop the process and run `spin up` again.
+
+## 6. Start Development
+
+1. Access your Coolify instance:
+   - URL: `http://localhost:8000`
+   - Login: `test@example.com`
+   - Password: `password`
+
+2. Additional development tools:
+   | Tool | URL | Note |
+   |------|-----|------|
+   | Laravel Horizon (scheduler) | `http://localhost:8000/horizon` | Only accessible when logged in as root user |
+   | Mailpit (email catcher) | `http://localhost:8025` | |
+   | Telescope (debugging tool) | `http://localhost:8000/telescope` | Disabled by default |
+
+> [!NOTE]
+> To enable Telescope, add the following to your `.env` file:
+> ```env
+> TELESCOPE_ENABLED=true
+> ```
+
+## 7. Create a Pull Request
+
+1. After making changes or adding a new service:
+   - Commit your changes to your forked repository.
+   - Push the changes to your GitHub account.
+
+2. Creating the Pull Request (PR):
+   - Navigate to the main Coolify repository on GitHub.
+   - Click the "Pull requests" tab.
+   - Click the green "New pull request" button.
+   - Choose your fork and branch as the compare branch.
+   - Click "Create pull request".
+
+3. Filling out the PR details:
+   - Give your PR a descriptive title.
+   - Use the Pull Request Template provided and fill in the details.
+
+> [!IMPORTANT]
+> Always set the base branch for your PR to the `next` branch of the Coolify repository, not the `main` branch.
+
+4. Submit your PR:
+   - Review your changes one last time.
+   - Click "Create pull request" to submit.
+
+> [!NOTE]
+> Make sure your PR is out of draft mode as soon as it's ready for review. PRs that are in draft mode for a long time may be closed by maintainers.
+
+After submission, maintainers will review your PR and may request changes or provide feedback.
+
+## Development Notes
+
+When working on Coolify, keep the following in mind:
+
+1. **Database Migrations**: After switching branches or making changes to the database structure, always run migrations:
+   ```bash
+   docker exec -it coolify php artisan migrate
+   ```
+
+2. **Resetting Development Setup**: To reset your development setup to a clean database with default values:
+   ```bash
+   docker exec -it coolify php artisan migrate:fresh --seed
+   ```
+
+3. **Troubleshooting**: If you encounter unexpected behavior, ensure your database is up-to-date with the latest migrations and if possible reset the development setup to eliminate any environment-specific issues.
+
+> [!IMPORTANT]
+> Forgetting to migrate the database can cause problems, so make it a habit to run migrations after pulling changes or switching branches.
+
+## Resetting Development Environment
+
+If you encounter issues or break your database or something else, follow these steps to start from a clean slate (works since `v4.0.0-beta.342`):
+
+1. Stop all running containers `ctrl + c`.
+
+2. Remove all Coolify containers:
+   ```bash
+   docker rm coolify coolify-db coolify-redis coolify-realtime coolify-testing-host coolify-minio coolify-vite-1 coolify-mail
+   ```
+
+3. Remove Coolify volumes (it is possible that the volumes have no `coolify` prefix on your machine, in that case remove the prefix from the command):
+   ```bash
+   docker volume rm coolify_dev_backups_data coolify_dev_postgres_data coolify_dev_redis_data coolify_dev_coolify_data coolify_dev_minio_data
+   ```
+
+4. Remove unused images:
+   ```bash
+   docker image prune -a
+   ```
+
+5. Start Coolify again:
+   ```bash
+   spin up
+   ```
+
+6. Run database migrations and seeders:
+   ```bash
+   docker exec -it coolify php artisan migrate:fresh --seed
+   ```
+
+After completing these steps, you'll have a fresh development setup.
+
+> [!IMPORTANT]
+> Always run database migrations and seeders after switching branches or pulling updates to ensure your local database structure matches the current codebase and includes necessary seed data.
+
+## Additional Contribution Guidelines
+
+### Contributing a New Service
+
+To add a new service to Coolify, please refer to our documentation:
+[Adding a New Service](https://coolify.io/docs/knowledge-base/contribute/service)
+
+### Contributing to Documentation
+
+To contribute to the Coolify documentation, please refer to this guide:
+[Contributing to the Coolify Documentation](https://github.com/coollabsio/documentation-coolify/blob/main/CONTRIBUTING.md)

CONTRIBUTION.md

@@ -1,34 +0,0 @@
-# Contributing
-
-> "First, thanks for considering to contribute to my project. 
-  It really means a lot!" - [@andrasbacsai](https://github.com/andrasbacsai)
-
-You can ask for guidance anytime on our 
-[Discord server](https://coollabs.io/discord) in the `#contribution` channel.
-
-## Code Contribution
-
-### 1) Setup your development environment
-
-- You need to have Docker Engine (or equivalent) [installed](https://docs.docker.com/engine/install/) on your system.
-- For better DX, install [Spin](https://serversideup.net/open-source/spin/).
-
-### 2) Set your environment variables
-
-- Copy [.env.development.example](./.env.development.example) to .env.
-
-## 3) Start & setup Coolify
-
-- Run `spin up` - You can notice that errors will be thrown. Don't worry.
-  - If you see weird permission errors, especially on Mac, run `sudo spin up` instead. 
-
-### 4) Start development
-You can login your Coolify instance at `localhost:8000` with `test@example.com` and `password`.
-
-Your horizon (Laravel scheduler): `localhost:8000/horizon` - Only reachable if you logged in with root user.
-
-Mails are caught by Mailpit: `localhost:8025`
-
-## New Service Contribution
-Check out the docs [here](https://coolify.io/docs/knowledge-base/add-a-service).
-

README.md

@@ -1,17 +1,19 @@
+![Latest Release Version](https://img.shields.io/badge/dynamic/json?labelColor=grey&color=6366f1&label=Latest_released_version&url=https%3A%2F%2Fcdn.coollabs.io%2Fcoolify%2Fversions.json&query=coolify.v4.version&style=for-the-badge
+)
+
 [![Bounty Issues](https://img.shields.io/static/v1?labelColor=grey&color=6366f1&label=Algora&message=%F0%9F%92%8E+Bounty+issues&style=for-the-badge)](https://console.algora.io/org/coollabsio/bounties/new)
-[![Open Bounties](https://img.shields.io/endpoint?url=https%3A%2F%2Fconsole.algora.io%2Fapi%2Fshields%2Fcoollabsio%2Fbounties%3Fstatus%3Dopen&style=for-the-badge)](https://console.algora.io/org/coollabsio/bounties?status=open)
-[![Rewarded Bounties](https://img.shields.io/endpoint?url=https%3A%2F%2Fconsole.algora.io%2Fapi%2Fshields%2Fcoollabsio%2Fbounties%3Fstatus%3Dcompleted&style=for-the-badge)](https://console.algora.io/org/coollabsio/bounties?status=completed)
+
 # About the Project
 
 Coolify is an open-source & self-hostable alternative to Heroku / Netlify / Vercel / etc. 
 
-It helps you to manage your servers, applications, databases on your own hardware, all you need is SSH connection. You can manage VPS, Bare Metal, Raspberry PI's anything.
+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.
 
-Imagine if you could have the ease of a cloud but with your own servers. That is **Coolify**.
+Imagine having the ease of a cloud but with your own servers. That is **Coolify**.
 
-No vendor lock-in, which means that all the configuration for your applications/databases/etc are saved to your server. So if you decide to stop using Coolify (oh nooo), you could still manage your running resources. You just lose the automations and all the magic. 🪄️
+No vendor lock-in, which means that all the configurations for your applications/databases/etc are saved to your server. So, if you decide to stop using Coolify (oh nooo), you could still manage your running resources. You lose the automations and all the magic. 🪄️
 
-For more information, take a look at our landing page [here](https://coolify.io).
+For more information, take a look at our landing page at [coolify.io](https://coolify.io).
 
 # Installation
 
@@ -22,32 +24,56 @@ You can find the installation script source [here](./scripts/install.sh).
 
 # Support
 
-Contact us [here](https://coolify.io/docs/contact).
+Contact us at [coolify.io/docs/contact](https://coolify.io/docs/contact).
 
 # Donations
-To stay completely free, open-source, no feature behind paywall and evolve the project, we need your help. If you like Coolify, please consider donating to help us fund the future development of the project.
+To stay completely free and open-source, with no feature behind the paywall and evolve the project, we need your help. If you like Coolify, please consider donating to help us fund the project's future development.
 
-https://coolify.io/sponsorships
+[coolify.io/sponsorships](https://coolify.io/sponsorships)
 
 Thank you so much!
 
-Special thanks to our biggest sponsor, [CCCareers](https://cccareers.org/)!
+Special thanks to our biggest sponsors!
+
+### Special Sponsors
+
+![image](https://github.com/user-attachments/assets/c95a07df-7c5a-4e77-a35a-81f25fcbece1)
+
+* [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.
+* [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.
+* [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.
+* [Glueops](https://www.glueops.dev/?ref=coolify.io) - A DevOps consulting company providing infrastructure automation and cloud optimization services.
+* [Ubicloud](https://ubicloud.com/?ref=coolify.io) - An open-source alternative to hyperscale cloud providers, offering high-performance cloud computing services.
+* [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.
 
-<a href="https://cccareers.org/" target="_blank"><img src="./other/logos/ccc-logo.webp" alt="cccareers logo" width="200"/></a>
 
 ## Github Sponsors ($40+)
-<a href="https://bc.direct"><img width="60px" alt="BC Direct" src="https://github.com/coollabsio/coolify/assets/5845193/a4063c41-95ed-4a32-8814-cd1475572e37"/></a>
-<a href="https://serpapi.com/?utm_source=coolify.io"><img width="60px" alt="SerpAPI" src="https://github.com/serpapi.png"/></a>
-<a href="https://typebot.io/?utm_source=coolify.io"><img src="https://pbs.twimg.com/profile_images/1509194008366657543/9I-C7uWT_400x400.jpg" width="60px" alt="typebot"/></a>
-<a href="https://www.quantcdn.io/?utm_source=coolify.io"><img src="https://github.com/quantcdn.png" width="60px" alt="QuantCDN"/></a> 
-<a href="https://www.runpod.io/?utm_source=coolify.io">
+<a href="https://serpapi.com/?ref=coolify.io"><img width="60px" alt="SerpAPI" src="https://github.com/serpapi.png"/></a>
+<a href="https://typebot.io/?ref=coolify.io"><img src="https://pbs.twimg.com/profile_images/1509194008366657543/9I-C7uWT_400x400.jpg" width="60px" alt="typebot"/></a>
+<a href="https://www.runpod.io/?ref=coolify.io">
 <svg style="width:60px;height:60px;background:#fff;" xmlns="http://www.w3.org/2000/svg" version="1.0" viewBox="0 0 200 200"><g><path d="M74.5 51.1c-25.4 14.9-27 16-29.6 20.2-1.8 3-1.9 5.3-1.9 32.3 0 21.7.3 29.4 1.3 30.6 1.9 2.5 46.7 27.9 48.5 27.6 1.5-.3 1.7-3.1 2-27.7.2-21.9 0-27.8-1.1-29.5-.8-1.2-9.9-6.8-20.2-12.6-10.3-5.8-19.4-11.5-20.2-12.7-1.8-2.6-.9-5.9 1.8-7.4 1.6-.8 6.3 0 21.8 4C87.8 78.7 98 81 99.6 81c4.4 0 49.9-25.9 49.9-28.4 0-1.6-3.4-2.8-24-8.2-13.2-3.5-25.1-6.3-26.5-6.3-1.4.1-12.4 5.9-24.5 13z"></path><path d="m137.2 68.1-3.3 2.1 6.3 3.7c3.5 2 6.3 4.3 6.3 5.1 0 .9-8 6.1-19.4 12.6-10.6 6-20 11.9-20.7 12.9-1.2 1.6-1.4 7.2-1.2 29.4.3 24.8.5 27.6 2 27.9 1.8.3 46.6-25.1 48.6-27.6.9-1.2 1.2-8.8 1.2-30.2s-.3-29-1.2-30.2c-1.6-1.9-12.1-7.8-13.9-7.8-.8 0-2.9 1-4.7 2.1z"></path></g></svg></a>
-<a href="https://lightspeed.run/?utm_source=coolify.io"><img src="https://github.com/lightspeedrun.png" width="60px" alt="Lightspeed.run"/></a>
-<a href="https://www.flint.sh/en/home?utm_source=coolify.io"> <img src="https://github.com/Flint-company.png" width="60px" alt="FlintCompany"/></a>
-<a href="https://americancloud.com/?utm_source=coolify.io"><img src="https://github.com/American-Cloud.png" width="60px" alt="American Cloud"/></a>
-<a href="https://cryptojobslist.com/?utm_source=coolify.io"><img src="https://github.com/cryptojobslist.png" width="60px" alt="CryptoJobsList" /></a>
-<a href="https://x.com/mrsmith9ja?utm_source=coolify.io"><img width="60px" alt="Thompson Edolo" src="https://github.com/verygreenboi.png"/></a>
-<a href="https://www.uxwizz.com/?utm_source=coolify.io"><img width="60px" alt="UXWizz" src="https://github.com/UXWizz.png"/></a>
+<a href="https://lightspeed.run/?ref=coolify.io"><img src="https://github.com/lightspeedrun.png" width="60px" alt="Lightspeed.run"/></a>
+<a href="https://www.flint.sh/en/home?ref=coolify.io"> <img src="https://github.com/Flint-company.png" width="60px" alt="FlintCompany"/></a>
+<a href="https://americancloud.com/?ref=coolify.io"><img src="https://github.com/American-Cloud.png" width="60px" alt="American Cloud"/></a>
+<a href="https://cryptojobslist.com/?ref=coolify.io"><img src="https://github.com/cryptojobslist.png" width="60px" alt="CryptoJobsList" /></a>
+<a href="https://codext.link/coolify-io?ref=coolify.io"><img src="./other/logos/codext.jpg" width="60px" alt="Codext" /></a>
+<a href="https://x.com/mrsmith9ja?ref=coolify.io"><img width="60px" alt="Thompson Edolo" src="https://github.com/verygreenboi.png"/></a>
+<a href="https://www.uxwizz.com/?ref=coolify.io"><img width="60px" alt="UXWizz" src="https://github.com/UXWizz.png"/></a>
 <a href="https://github.com/Flowko"><img src="https://barrad.me/_ipx/f_webp&s_300x300/younes.jpg" width="60px" alt="Younes Barrad" /></a>
 <a href="https://github.com/automazeio"><img src="https://github.com/automazeio.png" width="60px" alt="Automaze" /></a>
 <a href="https://github.com/corentinclichy"><img src="https://github.com/corentinclichy.png" width="60px" alt="Corentin Clichy" /></a>
@@ -57,8 +83,11 @@ Special thanks to our biggest sponsor, [CCCareers](https://cccareers.org/)!
 <a href="https://github.com/aniftyco"><img src="https://github.com/aniftyco.png" width="60px" alt="NiftyCo" /></a>
 <a href="https://github.com/iujlaki"><img src="https://github.com/iujlaki.png" width="60px" alt="Imre Ujlaki" /></a>
 <a href="https://il.ly"><img src="https://github.com/Illyism.png" width="60px" alt="Ilias Ism" /></a>
+<a href="https://www.breakcold.com/?utm_source=coolify.io"><img src="https://github.com/breakcold.png" width="60px" alt="Breakcold" /></a>
 <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>
 
 ## Organizations
 <a href="https://opencollective.com/coollabsio/organization/0/website"><img src="https://opencollective.com/coollabsio/organization/0/avatar.svg"></a>
@@ -79,9 +108,9 @@ Special thanks to our biggest sponsor, [CCCareers](https://cccareers.org/)!
 
 # Cloud
 
-If you do not want to self-host Coolify, there is a paid cloud version available: https://app.coolify.io
+If you do not want to self-host Coolify, there is a paid cloud version available: [app.coolify.io](https://app.coolify.io)
 
-For more information & pricing, take a look at our landing page [here](https://coolify.io).
+For more information & pricing, take a look at our landing page [coolify.io](https://coolify.io).
 
 ## Why should I use the Cloud version?
 The recommended way to use Coolify is to have one server for Coolify and one (or more) for the resources you are deploying. A server is around 4-5$/month.
@@ -105,7 +134,7 @@ By subscribing to the cloud version, you get the Coolify server for the same pri
 </a>
 </p>
 
-<a href="https://www.producthunt.com/posts/coolify?utm_source=badge-featured&utm_medium=badge&utm_souce=badge-coolify" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/featured.svg?post_id=338273&theme=light" alt="Coolify - An&#0032;open&#0045;source&#0032;&#0038;&#0032;self&#0045;hostable&#0032;Heroku&#0044;&#0032;Netlify&#0032;alternative | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a>
+<a href="https://www.producthunt.com/posts/coolify?ref=badge-featured&utm_medium=badge&utm_souce=badge-coolify" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/featured.svg?post_id=338273&theme=light" alt="Coolify - An&#0032;open&#0045;source&#0032;&#0038;&#0032;self&#0045;hostable&#0032;Heroku&#0044;&#0032;Netlify&#0032;alternative | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a>
 
 <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>
 

RELEASE.md

@@ -0,0 +1,130 @@
+# 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.
+
+## Table of Contents
+- [Release Process](#release-process)
+- [Version Types](#version-types)
+  - [Stable](#stable)
+  - [Nightly](#nightly)
+  - [Beta](#beta)
+- [Version Availability](#version-availability)
+  - [Self-Hosted](#self-hosted)
+  - [Cloud](#cloud)
+- [Manually Update to Specific Versions](#manually-update-to-specific-versions)
+
+## Release Process
+
+1. **Development on `next` or Feature Branches**
+   - 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.
+
+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.
+
+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)
+
+> [!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.**
+
+## Version Types
+
+<details>
+  <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.
+  - **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`).
+  - **Installation Command:**
+    ```bash
+    curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
+    ```
+
+</details>
+
+<details>
+  <summary><strong>Nightly</strong></summary>
+
+- **Nightly**
+  - 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
+  - **Installation Command:**
+    ```bash
+    curl -fsSL https://cdn.coollabs.io/coolify-nightly/install.sh | bash -s next
+    ```
+
+</details>
+
+<details>
+  <summary><strong>Beta</strong></summary>
+
+- **Beta**
+  - Test releases for the upcoming stable version.
+  - **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`).
+  - **Installation Command:**
+    ```bash
+    curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
+    ```
+
+</details>
+
+> [!WARNING]
+> Do not use nightly/beta builds in production as there is no guarantee of stability.
+
+## Version Availability
+
+When a new version is released and a new GitHub release is created, it doesn't immediately become available for your instance. Here's how version availability works for different instance types.
+
+### Self-Hosted
+
+- **Update Frequency:** More frequent updates, especially on the nightly release channel.
+- **Update Availability:** New versions are available once the CDN has been updated.
+- **Update Methods:**
+  1. **Manual Update in Instance Settings:**
+     - Go to `Settings > Update Check Frequency` and click the `Check Manually` button.
+     - If an update is available, an upgrade button will appear on the sidebar.
+  2. **Automatic Update:**
+     - If enabled, the instance will update automatically at the time set in the settings.
+  3. **Re-run Installation Script:**
+     - Run the installation script again to upgrade to the latest version available on the CDN:
+     ```bash
+     curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
+     ```
+
+> [!IMPORTANT]
+> If a new release is available on GitHub but your instance hasn't updated yet or no upgrade button is shown in the UI, the CDN might not have been updated yet. This intentional delay ensures stability and allows for hotfixes before official release.
+
+### Cloud
+
+- **Update Frequency:** Less frequent as it's a managed service.
+- **Update Availability:** New versions are available once Andras has updated the cloud version manually.
+- **Update Method:**
+  - Updates are managed by Andras, who ensures each cloud version is thoroughly tested and stable before releasing it.
+
+> [!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
+
+> [!CAUTION]  
+> Updating to unreleased versions is not recommended and may cause issues. Use at your own risk!
+
+To update your Coolify instance to a specific (unreleased) version, use the following command:
+
+```bash
+curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash -s <version>
+```
+Replace `<version>` with the version you want to update to (for example `4.0.0-beta.332`).

app/Actions/Application/LoadComposeFile.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Actions\Application;
+
+use App\Models\Application;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class LoadComposeFile
+{
+    use AsAction;
+
+    public function handle(Application $application)
+    {
+        $application->loadComposeFile();
+    }
+}

app/Actions/Application/StopApplication.php

@@ -2,42 +2,43 @@
 
 namespace App\Actions\Application;
 
+use App\Actions\Server\CleanupDocker;
 use App\Models\Application;
-use App\Models\StandaloneDocker;
-use App\Notifications\Application\StatusChanged;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class StopApplication
 {
     use AsAction;
-    public function handle(Application $application)
-    {
-        if ($application->destination->server->isSwarm()) {
-            instant_remote_process(["docker stack rm {$application->uuid}"], $application->destination->server);
-            return;
-        }
 
-        $servers = collect([]);
-        $servers->push($application->destination->server);
-        $application->additional_servers->map(function ($server) use ($servers) {
-            $servers->push($server);
-        });
-        foreach ($servers as $server) {
-            if (!$server->isFunctional()) {
+    public function handle(Application $application, bool $previewDeployments = false, bool $dockerCleanup = true)
+    {
+        try {
+            $server = $application->destination->server;
+            if (! $server->isFunctional()) {
                 return 'Server is not functional';
             }
-            $containers = getCurrentApplicationContainerStatus($server, $application->id, 0);
-            if ($containers->count() > 0) {
-                foreach ($containers as $container) {
-                    $containerName = data_get($container, 'Names');
-                    if ($containerName) {
-                        instant_remote_process(
-                            ["docker rm -f {$containerName}"],
-                            $server
-                        );
-                    }
-                }
+            ray('Stopping application: '.$application->name);
+
+            if ($server->isSwarm()) {
+                instant_remote_process(["docker stack rm {$application->uuid}"], $server);
+
+                return;
             }
+
+            $containersToStop = $application->getContainersToStop($previewDeployments);
+            $application->stopContainers($containersToStop, $server);
+
+            if ($application->build_pack === 'dockercompose') {
+                $application->delete_connected_networks($application->uuid);
+            }
+
+            if ($dockerCleanup) {
+                CleanupDocker::dispatch($server, true);
+            }
+        } catch (\Exception $e) {
+            ray($e->getMessage());
+
+            return $e->getMessage();
         }
     }
 }

app/Actions/Application/StopApplicationOneServer.php

@@ -9,12 +9,13 @@ use Lorisleiva\Actions\Concerns\AsAction;
 class StopApplicationOneServer
 {
     use AsAction;
+
     public function handle(Application $application, Server $server)
     {
         if ($application->destination->server->isSwarm()) {
             return;
         }
-        if (!$server->isFunctional()) {
+        if (! $server->isFunctional()) {
             return 'Server is not functional';
         }
         try {
@@ -32,6 +33,7 @@ class StopApplicationOneServer
             }
         } catch (\Exception $e) {
             ray($e->getMessage());
+
             return $e->getMessage();
         }
     }

app/Actions/CoolifyTask/PrepareCoolifyTask.php

@@ -3,6 +3,7 @@
 namespace App\Actions\CoolifyTask;
 
 use App\Data\CoolifyTaskArgs;
+use App\Enums\ActivityTypes;
 use App\Jobs\CoolifyTask;
 use Spatie\Activitylog\Models\Activity;
 
@@ -14,6 +15,7 @@ use Spatie\Activitylog\Models\Activity;
 class PrepareCoolifyTask
 {
     protected Activity $activity;
+
     protected CoolifyTaskArgs $remoteProcessArgs;
 
     public function __construct(CoolifyTaskArgs $remoteProcessArgs)
@@ -28,20 +30,31 @@ class PrepareCoolifyTask
                 ->withProperties($properties)
                 ->performedOn($remoteProcessArgs->model)
                 ->event($remoteProcessArgs->type)
-                ->log("[]");
+                ->log('[]');
         } else {
             $this->activity = activity()
                 ->withProperties($remoteProcessArgs->toArray())
                 ->event($remoteProcessArgs->type)
-                ->log("[]");
+                ->log('[]');
         }
     }
 
     public function __invoke(): Activity
     {
-        $job = new CoolifyTask($this->activity, ignore_errors: $this->remoteProcessArgs->ignore_errors, call_event_on_finish: $this->remoteProcessArgs->call_event_on_finish, call_event_data: $this->remoteProcessArgs->call_event_data);
-        dispatch($job);
+        $job = new CoolifyTask(
+            activity: $this->activity,
+            ignore_errors: $this->remoteProcessArgs->ignore_errors,
+            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);
+        }
         $this->activity->refresh();
+
         return $this->activity;
     }
 }

app/Actions/CoolifyTask/RunRemoteProcess.php

@@ -4,6 +4,7 @@ namespace App\Actions\CoolifyTask;
 
 use App\Enums\ActivityTypes;
 use App\Enums\ProcessStatus;
+use App\Helpers\SshMultiplexingHelper;
 use App\Jobs\ApplicationDeploymentJob;
 use App\Models\Server;
 use Illuminate\Process\ProcessResult;
@@ -39,7 +40,7 @@ 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) {
+        if ($activity->getExtraProperty('type') !== ActivityTypes::INLINE->value && $activity->getExtraProperty('type') !== ActivityTypes::COMMAND->value) {
             throw new \RuntimeException('Incompatible Activity to run a remote command.');
         }
 
@@ -69,7 +70,7 @@ class RunRemoteProcess
         return collect($decoded)
             ->sortBy(fn ($i) => $i['order'])
             ->map(fn ($i) => $i['output'])
-            ->implode("");
+            ->implode('');
     }
 
     public function __invoke(): ProcessResult
@@ -91,7 +92,7 @@ class RunRemoteProcess
             if ($processResult->exitCode() == 0) {
                 $status = ProcessStatus::FINISHED;
             }
-            if ($processResult->exitCode() != 0 && !$this->ignore_errors) {
+            if ($processResult->exitCode() != 0 && ! $this->ignore_errors) {
                 $status = ProcessStatus::ERROR;
             }
             // if (($processResult->exitCode() == 0 && $this->is_finished) || $this->activity->properties->get('status') === ProcessStatus::FINISHED->value) {
@@ -109,14 +110,14 @@ class RunRemoteProcess
             'status' => $status->value,
         ]);
         $this->activity->save();
-        if ($processResult->exitCode() != 0 && !$this->ignore_errors) {
+        if ($processResult->exitCode() != 0 && ! $this->ignore_errors) {
             throw new \RuntimeException($processResult->errorOutput(), $processResult->exitCode());
         }
         if ($this->call_event_on_finish) {
             try {
                 if ($this->call_event_data) {
                     event(resolve("App\\Events\\$this->call_event_on_finish", [
-                        "data" => $this->call_event_data,
+                        'data' => $this->call_event_data,
                     ]));
                 } else {
                     event(resolve("App\\Events\\$this->call_event_on_finish", [
@@ -127,6 +128,7 @@ class RunRemoteProcess
                 ray($e);
             }
         }
+
         return $processResult;
     }
 
@@ -136,7 +138,7 @@ class RunRemoteProcess
         $command = $this->activity->getExtraProperty('command');
         $server = Server::whereUuid($server_uuid)->firstOrFail();
 
-        return generateSshCommand($server, $command);
+        return SshMultiplexingHelper::generateSshCommand($server, $command);
     }
 
     protected function handleOutput(string $type, string $output)
@@ -182,6 +184,7 @@ class RunRemoteProcess
         if ($description === null || count($description) === 0) {
             return 1;
         }
+
         return end($description)['order'] + 1;
     }
 

app/Actions/Database/RestartDatabase.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Actions\Database;
+
+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 RestartDatabase
+{
+    use AsAction;
+
+    public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database)
+    {
+        $server = $database->destination->server;
+        if (! $server->isFunctional()) {
+            return 'Server is not functional';
+        }
+        StopDatabase::run($database);
+
+        return StartDatabase::run($database);
+    }
+}

app/Actions/Database/StartClickhouse.php

@@ -3,25 +3,25 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneClickhouse;
-use Illuminate\Support\Str;
-use Symfony\Component\Yaml\Yaml;
 use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
 
 class StartClickhouse
 {
     use AsAction;
 
     public StandaloneClickhouse $database;
+
     public array $commands = [];
+
     public string $configuration_dir;
 
     public function handle(StandaloneClickhouse $database)
     {
         $this->database = $database;
 
-
         $container_name = $this->database->uuid;
-        $this->configuration_dir = database_configuration_dir() . '/' . $container_name;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
             "echo 'Starting {$database->name}.'",
@@ -57,7 +57,7 @@ class StartClickhouse
                         'interval' => '5s',
                         'timeout' => '5s',
                         'retries' => 10,
-                        'start_period' => '5s'
+                        'start_period' => '5s',
                     ],
                     'mem_limit' => $this->database->limits_memory,
                     'memswap_limit' => $this->database->limits_memory_swap,
@@ -65,28 +65,21 @@ class StartClickhouse
                     'mem_reservation' => $this->database->limits_memory_reservation,
                     'cpus' => (float) $this->database->limits_cpus,
                     'cpu_shares' => $this->database->limits_cpu_shares,
-                ]
+                ],
             ],
             'networks' => [
                 $this->database->destination->network => [
                     'external' => true,
                     'name' => $this->database->destination->network,
                     'attachable' => true,
-                ]
-            ]
+                ],
+            ],
         ];
-        if (!is_null($this->database->limits_cpuset)) {
+        if (! is_null($this->database->limits_cpuset)) {
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => "tcp://127.0.0.1:24224",
-                    'fluentd-async' => "true",
-                    'fluentd-sub-second-precision' => "true",
-                ]
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -102,6 +95,11 @@ class StartClickhouse
         if (count($volume_names) > 0) {
             $docker_compose['volumes'] = $volume_names;
         }
+
+        // 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_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";
@@ -111,6 +109,7 @@ class StartClickhouse
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
+
         return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
     }
 
@@ -119,12 +118,13 @@ class StartClickhouse
         $local_persistent_volumes = [];
         foreach ($this->database->persistentStorages as $persistentStorage) {
             if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
-                $local_persistent_volumes[] = $persistentStorage->host_path . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
             } else {
                 $volume_name = $persistentStorage->name;
-                $local_persistent_volumes[] = $volume_name . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
             }
         }
+
         return $local_persistent_volumes;
     }
 
@@ -141,6 +141,7 @@ class StartClickhouse
                 'external' => false,
             ];
         }
+
         return $local_persistent_volumes_names;
     }
 
@@ -151,14 +152,16 @@ class StartClickhouse
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('CLICKHOUSE_ADMIN_USER'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('CLICKHOUSE_ADMIN_USER'))->isEmpty()) {
             $environment_variables->push("CLICKHOUSE_ADMIN_USER={$this->database->clickhouse_admin_user}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('CLICKHOUSE_ADMIN_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('CLICKHOUSE_ADMIN_PASSWORD'))->isEmpty()) {
             $environment_variables->push("CLICKHOUSE_ADMIN_PASSWORD={$this->database->clickhouse_admin_password}");
         }
 
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
 }

app/Actions/Database/StartDatabase.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Actions\Database;
+
+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 StartDatabase
+{
+    use AsAction;
+
+    public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database)
+    {
+        $server = $database->destination->server;
+        if (! $server->isFunctional()) {
+            return 'Server is not functional';
+        }
+        switch ($database->getMorphClass()) {
+            case 'App\Models\StandalonePostgresql':
+                $activity = StartPostgresql::run($database);
+                break;
+            case 'App\Models\StandaloneRedis':
+                $activity = StartRedis::run($database);
+                break;
+            case 'App\Models\StandaloneMongodb':
+                $activity = StartMongodb::run($database);
+                break;
+            case 'App\Models\StandaloneMysql':
+                $activity = StartMysql::run($database);
+                break;
+            case 'App\Models\StandaloneMariadb':
+                $activity = StartMariadb::run($database);
+                break;
+            case 'App\Models\StandaloneKeydb':
+                $activity = StartKeydb::run($database);
+                break;
+            case 'App\Models\StandaloneDragonfly':
+                $activity = StartDragonfly::run($database);
+                break;
+            case 'App\Models\StandaloneClickhouse':
+                $activity = StartClickhouse::run($database);
+                break;
+        }
+        if ($database->is_public && $database->public_port) {
+            StartDatabaseProxy::dispatch($database);
+        }
+
+        return $activity;
+    }
+}

app/Actions/Database/StartDatabaseProxy.php

@@ -69,19 +69,19 @@ class StartDatabaseProxy
         }
         if ($type === 'App\Models\StandaloneRedis') {
             $internalPort = 6379;
-        } else if ($type === 'App\Models\StandalonePostgresql') {
+        } elseif ($type === 'App\Models\StandalonePostgresql') {
             $internalPort = 5432;
-        } else if ($type === 'App\Models\StandaloneMongodb') {
+        } elseif ($type === 'App\Models\StandaloneMongodb') {
             $internalPort = 27017;
-        } else if ($type === 'App\Models\StandaloneMysql') {
+        } elseif ($type === 'App\Models\StandaloneMysql') {
             $internalPort = 3306;
-        } else if ($type === 'App\Models\StandaloneMariadb') {
+        } elseif ($type === 'App\Models\StandaloneMariadb') {
             $internalPort = 3306;
-        } else if ($type === 'App\Models\StandaloneKeydb') {
+        } elseif ($type === 'App\Models\StandaloneKeydb') {
             $internalPort = 6379;
-        } else if ($type === 'App\Models\StandaloneDragonfly') {
+        } elseif ($type === 'App\Models\StandaloneDragonfly') {
             $internalPort = 6379;
-        } else if ($type === 'App\Models\StandaloneClickhouse') {
+        } elseif ($type === 'App\Models\StandaloneClickhouse') {
             $internalPort = 9000;
         }
         $configuration_dir = database_proxy_dir($database->uuid);
@@ -101,7 +101,7 @@ class StartDatabaseProxy
        }
     }
     EOF;
-        $dockerfile = <<< EOF
+        $dockerfile = <<< 'EOF'
     FROM nginx:stable-alpine
 
     COPY nginx.conf /etc/nginx/nginx.conf
@@ -113,7 +113,7 @@ class StartDatabaseProxy
                         'context' => $configuration_dir,
                         'dockerfile' => 'Dockerfile',
                     ],
-                    'image' => "nginx:stable-alpine",
+                    'image' => 'nginx:stable-alpine',
                     'container_name' => $proxyContainerName,
                     'restart' => RESTART_MODE,
                     'ports' => [
@@ -130,17 +130,17 @@ class StartDatabaseProxy
                         'interval' => '5s',
                         'timeout' => '5s',
                         'retries' => 3,
-                        'start_period' => '1s'
+                        'start_period' => '1s',
                     ],
-                ]
+                ],
             ],
             'networks' => [
                 $network => [
                     'external' => true,
                     'name' => $network,
                     'attachable' => true,
-                ]
-            ]
+                ],
+            ],
         ];
         $dockercompose_base64 = base64_encode(Yaml::dump($docker_compose, 4, 2));
         $nginxconf_base64 = base64_encode($nginxconf);

app/Actions/Database/StartDragonfly.php

@@ -3,19 +3,18 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneDragonfly;
-use Illuminate\Support\Facades\Storage;
-use Illuminate\Support\Str;
-use Symfony\Component\Yaml\Yaml;
 use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
 
 class StartDragonfly
 {
     use AsAction;
 
     public StandaloneDragonfly $database;
-    public array $commands = [];
-    public string $configuration_dir;
 
+    public array $commands = [];
+
+    public string $configuration_dir;
 
     public function handle(StandaloneDragonfly $database)
     {
@@ -24,7 +23,7 @@ class StartDragonfly
         $startCommand = "dragonfly --requirepass {$this->database->dragonfly_password}";
 
         $container_name = $this->database->uuid;
-        $this->configuration_dir = database_configuration_dir() . '/' . $container_name;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
             "echo 'Starting {$database->name}.'",
@@ -47,9 +46,6 @@ class StartDragonfly
                     'networks' => [
                         $this->database->destination->network,
                     ],
-                    'ulimits' => [
-                        'memlock'=> '-1'
-                    ],
                     'labels' => [
                         'coolify.managed' => 'true',
                     ],
@@ -58,7 +54,7 @@ class StartDragonfly
                         'interval' => '5s',
                         'timeout' => '5s',
                         'retries' => 10,
-                        'start_period' => '5s'
+                        'start_period' => '5s',
                     ],
                     'mem_limit' => $this->database->limits_memory,
                     'memswap_limit' => $this->database->limits_memory_swap,
@@ -66,28 +62,21 @@ class StartDragonfly
                     'mem_reservation' => $this->database->limits_memory_reservation,
                     'cpus' => (float) $this->database->limits_cpus,
                     'cpu_shares' => $this->database->limits_cpu_shares,
-                ]
+                ],
             ],
             'networks' => [
                 $this->database->destination->network => [
                     'external' => true,
                     'name' => $this->database->destination->network,
                     'attachable' => true,
-                ]
-            ]
+                ],
+            ],
         ];
-        if (!is_null($this->database->limits_cpuset)) {
+        if (! is_null($this->database->limits_cpuset)) {
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => "tcp://127.0.0.1:24224",
-                    'fluentd-async' => "true",
-                    'fluentd-sub-second-precision' => "true",
-                ]
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -103,6 +92,11 @@ class StartDragonfly
         if (count($volume_names) > 0) {
             $docker_compose['volumes'] = $volume_names;
         }
+
+        // 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_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";
@@ -112,6 +106,7 @@ class StartDragonfly
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
+
         return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
     }
 
@@ -120,12 +115,13 @@ class StartDragonfly
         $local_persistent_volumes = [];
         foreach ($this->database->persistentStorages as $persistentStorage) {
             if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
-                $local_persistent_volumes[] = $persistentStorage->host_path . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
             } else {
                 $volume_name = $persistentStorage->name;
-                $local_persistent_volumes[] = $volume_name . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
             }
         }
+
         return $local_persistent_volumes;
     }
 
@@ -142,6 +138,7 @@ class StartDragonfly
                 'external' => false,
             ];
         }
+
         return $local_persistent_volumes_names;
     }
 
@@ -152,7 +149,7 @@ class StartDragonfly
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
             $environment_variables->push("REDIS_PASSWORD={$this->database->dragonfly_password}");
         }
 

app/Actions/Database/StartKeydb.php

@@ -4,18 +4,18 @@ namespace App\Actions\Database;
 
 use App\Models\StandaloneKeydb;
 use Illuminate\Support\Facades\Storage;
-use Illuminate\Support\Str;
-use Symfony\Component\Yaml\Yaml;
 use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
 
 class StartKeydb
 {
     use AsAction;
 
     public StandaloneKeydb $database;
-    public array $commands = [];
-    public string $configuration_dir;
 
+    public array $commands = [];
+
+    public string $configuration_dir;
 
     public function handle(StandaloneKeydb $database)
     {
@@ -24,7 +24,7 @@ class StartKeydb
         $startCommand = "keydb-server --requirepass {$this->database->keydb_password} --appendonly yes";
 
         $container_name = $this->database->uuid;
-        $this->configuration_dir = database_configuration_dir() . '/' . $container_name;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
             "echo 'Starting {$database->name}.'",
@@ -56,7 +56,7 @@ class StartKeydb
                         'interval' => '5s',
                         'timeout' => '5s',
                         'retries' => 10,
-                        'start_period' => '5s'
+                        'start_period' => '5s',
                     ],
                     'mem_limit' => $this->database->limits_memory,
                     'memswap_limit' => $this->database->limits_memory_swap,
@@ -64,28 +64,21 @@ class StartKeydb
                     'mem_reservation' => $this->database->limits_memory_reservation,
                     'cpus' => (float) $this->database->limits_cpus,
                     'cpu_shares' => $this->database->limits_cpu_shares,
-                ]
+                ],
             ],
             'networks' => [
                 $this->database->destination->network => [
                     'external' => true,
                     'name' => $this->database->destination->network,
                     'attachable' => true,
-                ]
-            ]
+                ],
+            ],
         ];
-        if (!is_null($this->database->limits_cpuset)) {
+        if (! is_null($this->database->limits_cpuset)) {
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => "tcp://127.0.0.1:24224",
-                    'fluentd-async' => "true",
-                    'fluentd-sub-second-precision' => "true",
-                ]
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -101,15 +94,19 @@ class StartKeydb
         if (count($volume_names) > 0) {
             $docker_compose['volumes'] = $volume_names;
         }
-        if (!is_null($this->database->keydb_conf) || !empty($this->database->keydb_conf)) {
+        if (! is_null($this->database->keydb_conf) || ! empty($this->database->keydb_conf)) {
             $docker_compose['services'][$container_name]['volumes'][] = [
                 'type' => 'bind',
-                'source' => $this->configuration_dir . '/keydb.conf',
+                'source' => $this->configuration_dir.'/keydb.conf',
                 'target' => '/etc/keydb/keydb.conf',
                 'read_only' => true,
             ];
             $docker_compose['services'][$container_name]['command'] = "keydb-server /etc/keydb/keydb.conf --requirepass {$this->database->keydb_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_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";
@@ -119,6 +116,7 @@ class StartKeydb
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
+
         return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
     }
 
@@ -127,12 +125,13 @@ class StartKeydb
         $local_persistent_volumes = [];
         foreach ($this->database->persistentStorages as $persistentStorage) {
             if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
-                $local_persistent_volumes[] = $persistentStorage->host_path . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
             } else {
                 $volume_name = $persistentStorage->name;
-                $local_persistent_volumes[] = $volume_name . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
             }
         }
+
         return $local_persistent_volumes;
     }
 
@@ -149,6 +148,7 @@ class StartKeydb
                 'external' => false,
             ];
         }
+
         return $local_persistent_volumes_names;
     }
 
@@ -159,12 +159,15 @@ class StartKeydb
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
             $environment_variables->push("REDIS_PASSWORD={$this->database->keydb_password}");
         }
 
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
+
     private function add_custom_keydb()
     {
         if (is_null($this->database->keydb_conf) || empty($this->database->keydb_conf)) {

app/Actions/Database/StartMariadb.php

@@ -3,16 +3,17 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneMariadb;
-use Illuminate\Support\Str;
-use Symfony\Component\Yaml\Yaml;
 use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
 
 class StartMariadb
 {
     use AsAction;
 
     public StandaloneMariadb $database;
+
     public array $commands = [];
+
     public string $configuration_dir;
 
     public function handle(StandaloneMariadb $database)
@@ -20,7 +21,7 @@ class StartMariadb
         $this->database = $database;
 
         $container_name = $this->database->uuid;
-        $this->configuration_dir = database_configuration_dir() . '/' . $container_name;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
             "echo 'Starting {$database->name}.'",
@@ -46,11 +47,11 @@ class StartMariadb
                         'coolify.managed' => 'true',
                     ],
                     'healthcheck' => [
-                        'test' => ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"],
+                        'test' => ['CMD', 'healthcheck.sh', '--connect', '--innodb_initialized'],
                         'interval' => '5s',
                         'timeout' => '5s',
                         'retries' => 10,
-                        'start_period' => '5s'
+                        'start_period' => '5s',
                     ],
                     'mem_limit' => $this->database->limits_memory,
                     'memswap_limit' => $this->database->limits_memory_swap,
@@ -58,28 +59,21 @@ class StartMariadb
                     'mem_reservation' => $this->database->limits_memory_reservation,
                     'cpus' => (float) $this->database->limits_cpus,
                     'cpu_shares' => $this->database->limits_cpu_shares,
-                ]
+                ],
             ],
             'networks' => [
                 $this->database->destination->network => [
                     'external' => true,
                     'name' => $this->database->destination->network,
                     'attachable' => true,
-                ]
-            ]
+                ],
+            ],
         ];
-        if (!is_null($this->database->limits_cpuset)) {
+        if (! is_null($this->database->limits_cpuset)) {
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => "tcp://127.0.0.1:24224",
-                    'fluentd-async' => "true",
-                    'fluentd-sub-second-precision' => "true",
-                ]
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -95,14 +89,19 @@ class StartMariadb
         if (count($volume_names) > 0) {
             $docker_compose['volumes'] = $volume_names;
         }
-        if (!is_null($this->database->mariadb_conf) || !empty($this->database->mariadb_conf)) {
+        if (! is_null($this->database->mariadb_conf) || ! empty($this->database->mariadb_conf)) {
             $docker_compose['services'][$container_name]['volumes'][] = [
                 'type' => 'bind',
-                'source' => $this->configuration_dir . '/custom-config.cnf',
+                'source' => $this->configuration_dir.'/custom-config.cnf',
                 'target' => '/etc/mysql/conf.d/custom-config.cnf',
                 'read_only' => true,
             ];
         }
+
+        // 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_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";
@@ -112,6 +111,7 @@ class StartMariadb
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
+
         return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
     }
 
@@ -120,12 +120,13 @@ class StartMariadb
         $local_persistent_volumes = [];
         foreach ($this->database->persistentStorages as $persistentStorage) {
             if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
-                $local_persistent_volumes[] = $persistentStorage->host_path . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
             } else {
                 $volume_name = $persistentStorage->name;
-                $local_persistent_volumes[] = $volume_name . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
             }
         }
+
         return $local_persistent_volumes;
     }
 
@@ -142,6 +143,7 @@ class StartMariadb
                 'external' => false,
             ];
         }
+
         return $local_persistent_volumes_names;
     }
 
@@ -152,22 +154,26 @@ class StartMariadb
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MARIADB_ROOT_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MARIADB_ROOT_PASSWORD'))->isEmpty()) {
             $environment_variables->push("MARIADB_ROOT_PASSWORD={$this->database->mariadb_root_password}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MARIADB_DATABASE'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MARIADB_DATABASE'))->isEmpty()) {
             $environment_variables->push("MARIADB_DATABASE={$this->database->mariadb_database}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MARIADB_USER'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MARIADB_USER'))->isEmpty()) {
             $environment_variables->push("MARIADB_USER={$this->database->mariadb_user}");
         }
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MARIADB_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MARIADB_PASSWORD'))->isEmpty()) {
             $environment_variables->push("MARIADB_PASSWORD={$this->database->mariadb_password}");
         }
+
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
+
     private function add_custom_mysql()
     {
         if (is_null($this->database->mariadb_conf) || empty($this->database->mariadb_conf)) {

app/Actions/Database/StartMongodb.php

@@ -3,26 +3,27 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneMongodb;
-use Illuminate\Support\Str;
-use Symfony\Component\Yaml\Yaml;
 use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
 
 class StartMongodb
 {
     use AsAction;
 
     public StandaloneMongodb $database;
+
     public array $commands = [];
+
     public string $configuration_dir;
 
     public function handle(StandaloneMongodb $database)
     {
         $this->database = $database;
 
-        $startCommand = "mongod";
+        $startCommand = 'mongod';
 
         $container_name = $this->database->uuid;
-        $this->configuration_dir = database_configuration_dir() . '/' . $container_name;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
             "echo 'Starting {$database->name}.'",
@@ -51,14 +52,14 @@ class StartMongodb
                     ],
                     'healthcheck' => [
                         'test' => [
-                            "CMD",
-                            "echo",
-                            "ok"
+                            'CMD',
+                            'echo',
+                            'ok',
                         ],
                         'interval' => '5s',
                         'timeout' => '5s',
                         'retries' => 10,
-                        'start_period' => '5s'
+                        'start_period' => '5s',
                     ],
                     'mem_limit' => $this->database->limits_memory,
                     'memswap_limit' => $this->database->limits_memory_swap,
@@ -66,28 +67,21 @@ class StartMongodb
                     'mem_reservation' => $this->database->limits_memory_reservation,
                     'cpus' => (float) $this->database->limits_cpus,
                     'cpu_shares' => $this->database->limits_cpu_shares,
-                ]
+                ],
             ],
             'networks' => [
                 $this->database->destination->network => [
                     'external' => true,
                     'name' => $this->database->destination->network,
                     'attachable' => true,
-                ]
-            ]
+                ],
+            ],
         ];
-        if (!is_null($this->database->limits_cpuset)) {
+        if (! is_null($this->database->limits_cpuset)) {
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => "tcp://127.0.0.1:24224",
-                    'fluentd-async' => "true",
-                    'fluentd-sub-second-precision' => "true",
-                ]
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -103,23 +97,27 @@ class StartMongodb
         if (count($volume_names) > 0) {
             $docker_compose['volumes'] = $volume_names;
         }
-        if (!is_null($this->database->mongo_conf) || !empty($this->database->mongo_conf)) {
+        if (! is_null($this->database->mongo_conf) || ! empty($this->database->mongo_conf)) {
             $docker_compose['services'][$container_name]['volumes'][] = [
                 'type' => 'bind',
-                'source' => $this->configuration_dir . '/mongod.conf',
+                'source' => $this->configuration_dir.'/mongod.conf',
                 'target' => '/etc/mongo/mongod.conf',
                 'read_only' => true,
             ];
-            $docker_compose['services'][$container_name]['command'] =  $startCommand . ' --config /etc/mongo/mongod.conf';
+            $docker_compose['services'][$container_name]['command'] = $startCommand.' --config /etc/mongo/mongod.conf';
         }
         $this->add_default_database();
         $docker_compose['services'][$container_name]['volumes'][] = [
             'type' => 'bind',
-            'source' => $this->configuration_dir . '/docker-entrypoint-initdb.d',
+            'source' => $this->configuration_dir.'/docker-entrypoint-initdb.d',
             'target' => '/docker-entrypoint-initdb.d',
             'read_only' => true,
         ];
 
+        // 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_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";
@@ -129,6 +127,7 @@ class StartMongodb
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
+
         return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
     }
 
@@ -137,12 +136,13 @@ class StartMongodb
         $local_persistent_volumes = [];
         foreach ($this->database->persistentStorages as $persistentStorage) {
             if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
-                $local_persistent_volumes[] = $persistentStorage->host_path . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
             } else {
                 $volume_name = $persistentStorage->name;
-                $local_persistent_volumes[] = $volume_name . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
             }
         }
+
         return $local_persistent_volumes;
     }
 
@@ -159,6 +159,7 @@ class StartMongodb
                 'external' => false,
             ];
         }
+
         return $local_persistent_volumes_names;
     }
 
@@ -169,19 +170,23 @@ class StartMongodb
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MONGO_INITDB_ROOT_USERNAME'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MONGO_INITDB_ROOT_USERNAME'))->isEmpty()) {
             $environment_variables->push("MONGO_INITDB_ROOT_USERNAME={$this->database->mongo_initdb_root_username}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MONGO_INITDB_ROOT_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MONGO_INITDB_ROOT_PASSWORD'))->isEmpty()) {
             $environment_variables->push("MONGO_INITDB_ROOT_PASSWORD={$this->database->mongo_initdb_root_password}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MONGO_INITDB_DATABASE'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MONGO_INITDB_DATABASE'))->isEmpty()) {
             $environment_variables->push("MONGO_INITDB_DATABASE={$this->database->mongo_initdb_database}");
         }
+
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
+
     private function add_custom_mongo_conf()
     {
         if (is_null($this->database->mongo_conf) || empty($this->database->mongo_conf)) {
@@ -192,6 +197,7 @@ class StartMongodb
         $content_base64 = base64_encode($content);
         $this->commands[] = "echo '{$content_base64}' | base64 -d | tee $this->configuration_dir/{$filename} > /dev/null";
     }
+
     private function add_default_database()
     {
         $content = "db = db.getSiblingDB(\"{$this->database->mongo_initdb_database}\");db.createCollection('init_collection');db.createUser({user: \"{$this->database->mongo_initdb_root_username}\", pwd: \"{$this->database->mongo_initdb_root_password}\",roles: [{role:\"readWrite\",db:\"{$this->database->mongo_initdb_database}\"}]});";

app/Actions/Database/StartMysql.php

@@ -3,16 +3,17 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneMysql;
-use Illuminate\Support\Str;
-use Symfony\Component\Yaml\Yaml;
 use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
 
 class StartMysql
 {
     use AsAction;
 
     public StandaloneMysql $database;
+
     public array $commands = [];
+
     public string $configuration_dir;
 
     public function handle(StandaloneMysql $database)
@@ -20,7 +21,7 @@ class StartMysql
         $this->database = $database;
 
         $container_name = $this->database->uuid;
-        $this->configuration_dir = database_configuration_dir() . '/' . $container_name;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
             "echo 'Starting {$database->name}.'",
@@ -46,11 +47,11 @@ class StartMysql
                         'coolify.managed' => 'true',
                     ],
                     'healthcheck' => [
-                        'test' => ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p{$this->database->mysql_root_password}"],
+                        'test' => ['CMD', 'mysqladmin', 'ping', '-h', 'localhost', '-u', 'root', "-p{$this->database->mysql_root_password}"],
                         'interval' => '5s',
                         'timeout' => '5s',
                         'retries' => 10,
-                        'start_period' => '5s'
+                        'start_period' => '5s',
                     ],
                     'mem_limit' => $this->database->limits_memory,
                     'memswap_limit' => $this->database->limits_memory_swap,
@@ -58,28 +59,21 @@ class StartMysql
                     'mem_reservation' => $this->database->limits_memory_reservation,
                     'cpus' => (float) $this->database->limits_cpus,
                     'cpu_shares' => $this->database->limits_cpu_shares,
-                ]
+                ],
             ],
             'networks' => [
                 $this->database->destination->network => [
                     'external' => true,
                     'name' => $this->database->destination->network,
                     'attachable' => true,
-                ]
-            ]
+                ],
+            ],
         ];
-        if (!is_null($this->database->limits_cpuset)) {
+        if (! is_null($this->database->limits_cpuset)) {
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => "tcp://127.0.0.1:24224",
-                    'fluentd-async' => "true",
-                    'fluentd-sub-second-precision' => "true",
-                ]
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -95,14 +89,19 @@ class StartMysql
         if (count($volume_names) > 0) {
             $docker_compose['volumes'] = $volume_names;
         }
-        if (!is_null($this->database->mysql_conf) || !empty($this->database->mysql_conf)) {
+        if (! is_null($this->database->mysql_conf) || ! empty($this->database->mysql_conf)) {
             $docker_compose['services'][$container_name]['volumes'][] = [
                 'type' => 'bind',
-                'source' => $this->configuration_dir . '/custom-config.cnf',
+                'source' => $this->configuration_dir.'/custom-config.cnf',
                 'target' => '/etc/mysql/conf.d/custom-config.cnf',
                 'read_only' => true,
             ];
         }
+
+        // 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_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";
@@ -112,7 +111,8 @@ class StartMysql
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
-        return remote_process($this->commands, $database->destination->server,callEventOnFinish: 'DatabaseStatusChanged');
+
+        return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
     }
 
     private function generate_local_persistent_volumes()
@@ -120,12 +120,13 @@ class StartMysql
         $local_persistent_volumes = [];
         foreach ($this->database->persistentStorages as $persistentStorage) {
             if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
-                $local_persistent_volumes[] = $persistentStorage->host_path . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
             } else {
                 $volume_name = $persistentStorage->name;
-                $local_persistent_volumes[] = $volume_name . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
             }
         }
+
         return $local_persistent_volumes;
     }
 
@@ -142,6 +143,7 @@ class StartMysql
                 'external' => false,
             ];
         }
+
         return $local_persistent_volumes_names;
     }
 
@@ -152,22 +154,26 @@ class StartMysql
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MYSQL_ROOT_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MYSQL_ROOT_PASSWORD'))->isEmpty()) {
             $environment_variables->push("MYSQL_ROOT_PASSWORD={$this->database->mysql_root_password}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MYSQL_DATABASE'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MYSQL_DATABASE'))->isEmpty()) {
             $environment_variables->push("MYSQL_DATABASE={$this->database->mysql_database}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MYSQL_USER'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MYSQL_USER'))->isEmpty()) {
             $environment_variables->push("MYSQL_USER={$this->database->mysql_user}");
         }
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MYSQL_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MYSQL_PASSWORD'))->isEmpty()) {
             $environment_variables->push("MYSQL_PASSWORD={$this->database->mysql_password}");
         }
+
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
+
     private function add_custom_mysql()
     {
         if (is_null($this->database->mysql_conf) || empty($this->database->mysql_conf)) {

app/Actions/Database/StartPostgresql.php

@@ -3,29 +3,31 @@
 namespace App\Actions\Database;
 
 use App\Models\StandalonePostgresql;
-use Illuminate\Support\Str;
-use Symfony\Component\Yaml\Yaml;
 use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
 
 class StartPostgresql
 {
     use AsAction;
 
     public StandalonePostgresql $database;
+
     public array $commands = [];
+
     public array $init_scripts = [];
+
     public string $configuration_dir;
 
     public function handle(StandalonePostgresql $database)
     {
         $this->database = $database;
         $container_name = $this->database->uuid;
-        $this->configuration_dir = database_configuration_dir() . '/' . $container_name;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
             "echo 'Starting {$database->name}.'",
             "mkdir -p $this->configuration_dir",
-            "mkdir -p $this->configuration_dir/docker-entrypoint-initdb.d/"
+            "mkdir -p $this->configuration_dir/docker-entrypoint-initdb.d/",
         ];
 
         $persistent_storages = $this->generate_local_persistent_volumes();
@@ -50,13 +52,13 @@ class StartPostgresql
                     ],
                     'healthcheck' => [
                         'test' => [
-                            "CMD-SHELL",
-                            "psql -U {$this->database->postgres_user} -d {$this->database->postgres_db} -c 'SELECT 1' || exit 1"
+                            'CMD-SHELL',
+                            "psql -U {$this->database->postgres_user} -d {$this->database->postgres_db} -c 'SELECT 1' || exit 1",
                         ],
                         'interval' => '5s',
                         'timeout' => '5s',
                         'retries' => 10,
-                        'start_period' => '5s'
+                        'start_period' => '5s',
                     ],
                     'mem_limit' => $this->database->limits_memory,
                     'memswap_limit' => $this->database->limits_memory_swap,
@@ -64,28 +66,21 @@ class StartPostgresql
                     'mem_reservation' => $this->database->limits_memory_reservation,
                     'cpus' => (float) $this->database->limits_cpus,
                     'cpu_shares' => $this->database->limits_cpu_shares,
-                ]
+                ],
             ],
             'networks' => [
                 $this->database->destination->network => [
                     'external' => true,
                     'name' => $this->database->destination->network,
                     'attachable' => true,
-                ]
-            ]
+                ],
+            ],
         ];
-        if (!is_null($this->database->limits_cpuset)) {
+        if (! is_null($this->database->limits_cpuset)) {
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => "tcp://127.0.0.1:24224",
-                    'fluentd-async' => "true",
-                    'fluentd-sub-second-precision' => "true",
-                ]
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -106,15 +101,15 @@ class StartPostgresql
                 $docker_compose['services'][$container_name]['volumes'][] = [
                     'type' => 'bind',
                     'source' => $init_script,
-                    'target' => '/docker-entrypoint-initdb.d/' . basename($init_script),
+                    'target' => '/docker-entrypoint-initdb.d/'.basename($init_script),
                     'read_only' => true,
                 ];
             }
         }
-        if (!is_null($this->database->postgres_conf) && !empty($this->database->postgres_conf)) {
+        if (! is_null($this->database->postgres_conf) && ! empty($this->database->postgres_conf)) {
             $docker_compose['services'][$container_name]['volumes'][] = [
                 'type' => 'bind',
-                'source' => $this->configuration_dir . '/custom-postgres.conf',
+                'source' => $this->configuration_dir.'/custom-postgres.conf',
                 'target' => '/etc/postgresql/postgresql.conf',
                 'read_only' => true,
             ];
@@ -124,6 +119,10 @@ class StartPostgresql
                 'config_file=/etc/postgresql/postgresql.conf',
             ];
         }
+        // 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_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";
@@ -133,6 +132,7 @@ class StartPostgresql
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
+
         return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
     }
 
@@ -141,12 +141,13 @@ class StartPostgresql
         $local_persistent_volumes = [];
         foreach ($this->database->persistentStorages as $persistentStorage) {
             if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
-                $local_persistent_volumes[] = $persistentStorage->host_path . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
             } else {
                 $volume_name = $persistentStorage->name;
-                $local_persistent_volumes[] = $volume_name . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
             }
         }
+
         return $local_persistent_volumes;
     }
 
@@ -163,6 +164,7 @@ class StartPostgresql
                 'external' => false,
             ];
         }
+
         return $local_persistent_volumes_names;
     }
 
@@ -173,20 +175,23 @@ class StartPostgresql
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('POSTGRES_USER'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('POSTGRES_USER'))->isEmpty()) {
             $environment_variables->push("POSTGRES_USER={$this->database->postgres_user}");
         }
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('PGUSER'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('PGUSER'))->isEmpty()) {
             $environment_variables->push("PGUSER={$this->database->postgres_user}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('POSTGRES_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('POSTGRES_PASSWORD'))->isEmpty()) {
             $environment_variables->push("POSTGRES_PASSWORD={$this->database->postgres_password}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('POSTGRES_DB'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('POSTGRES_DB'))->isEmpty()) {
             $environment_variables->push("POSTGRES_DB={$this->database->postgres_db}");
         }
+
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
 
@@ -203,6 +208,7 @@ class StartPostgresql
             $this->init_scripts[] = "$this->configuration_dir/docker-entrypoint-initdb.d/{$filename}";
         }
     }
+
     private function add_custom_conf()
     {
         if (is_null($this->database->postgres_conf) || empty($this->database->postgres_conf)) {
@@ -210,7 +216,7 @@ class StartPostgresql
         }
         $filename = 'custom-postgres.conf';
         $content = $this->database->postgres_conf;
-        if (!str($content)->contains('listen_addresses')) {
+        if (! str($content)->contains('listen_addresses')) {
             $content .= "\nlisten_addresses = '*'";
             $this->database->postgres_conf = $content;
             $this->database->save();

app/Actions/Database/StartRedis.php

@@ -4,18 +4,18 @@ namespace App\Actions\Database;
 
 use App\Models\StandaloneRedis;
 use Illuminate\Support\Facades\Storage;
-use Illuminate\Support\Str;
-use Symfony\Component\Yaml\Yaml;
 use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
 
 class StartRedis
 {
     use AsAction;
 
     public StandaloneRedis $database;
-    public array $commands = [];
-    public string $configuration_dir;
 
+    public array $commands = [];
+
+    public string $configuration_dir;
 
     public function handle(StandaloneRedis $database)
     {
@@ -24,7 +24,7 @@ class StartRedis
         $startCommand = "redis-server --requirepass {$this->database->redis_password} --appendonly yes";
 
         $container_name = $this->database->uuid;
-        $this->configuration_dir = database_configuration_dir() . '/' . $container_name;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
         $this->commands = [
             "echo 'Starting {$database->name}.'",
@@ -55,12 +55,12 @@ class StartRedis
                         'test' => [
                             'CMD-SHELL',
                             'redis-cli',
-                            'ping'
+                            'ping',
                         ],
                         'interval' => '5s',
                         'timeout' => '5s',
                         'retries' => 10,
-                        'start_period' => '5s'
+                        'start_period' => '5s',
                     ],
                     'mem_limit' => $this->database->limits_memory,
                     'memswap_limit' => $this->database->limits_memory_swap,
@@ -68,28 +68,21 @@ class StartRedis
                     'mem_reservation' => $this->database->limits_memory_reservation,
                     'cpus' => (float) $this->database->limits_cpus,
                     'cpu_shares' => $this->database->limits_cpu_shares,
-                ]
+                ],
             ],
             'networks' => [
                 $this->database->destination->network => [
                     'external' => true,
                     'name' => $this->database->destination->network,
                     'attachable' => true,
-                ]
-            ]
+                ],
+            ],
         ];
-        if (!is_null($this->database->limits_cpuset)) {
+        if (! is_null($this->database->limits_cpuset)) {
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => "tcp://127.0.0.1:24224",
-                    'fluentd-async' => "true",
-                    'fluentd-sub-second-precision' => "true",
-                ]
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -105,15 +98,20 @@ class StartRedis
         if (count($volume_names) > 0) {
             $docker_compose['volumes'] = $volume_names;
         }
-        if (!is_null($this->database->redis_conf) || !empty($this->database->redis_conf)) {
+        if (! is_null($this->database->redis_conf) || ! empty($this->database->redis_conf)) {
             $docker_compose['services'][$container_name]['volumes'][] = [
                 'type' => 'bind',
-                'source' => $this->configuration_dir . '/redis.conf',
+                'source' => $this->configuration_dir.'/redis.conf',
                 '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_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";
@@ -123,6 +121,7 @@ class StartRedis
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
+
         return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
     }
 
@@ -131,12 +130,13 @@ class StartRedis
         $local_persistent_volumes = [];
         foreach ($this->database->persistentStorages as $persistentStorage) {
             if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
-                $local_persistent_volumes[] = $persistentStorage->host_path . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
             } else {
                 $volume_name = $persistentStorage->name;
-                $local_persistent_volumes[] = $volume_name . ':' . $persistentStorage->mount_path;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
             }
         }
+
         return $local_persistent_volumes;
     }
 
@@ -153,6 +153,7 @@ class StartRedis
                 'external' => false,
             ];
         }
+
         return $local_persistent_volumes_names;
     }
 
@@ -163,12 +164,15 @@ class StartRedis
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
             $environment_variables->push("REDIS_PASSWORD={$this->database->redis_password}");
         }
 
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
+
     private function add_custom_redis()
     {
         if (is_null($this->database->redis_conf) || empty($this->database->redis_conf)) {

app/Actions/Database/StopDatabase.php

@@ -2,6 +2,7 @@
 
 namespace App\Actions\Database;
 
+use App\Actions\Server\CleanupDocker;
 use App\Models\StandaloneClickhouse;
 use App\Models\StandaloneDragonfly;
 use App\Models\StandaloneKeydb;
@@ -10,26 +11,65 @@ use App\Models\StandaloneMongodb;
 use App\Models\StandaloneMysql;
 use App\Models\StandalonePostgresql;
 use App\Models\StandaloneRedis;
+use Illuminate\Support\Facades\Process;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class StopDatabase
 {
     use AsAction;
 
-    public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database)
+    public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database, bool $isDeleteOperation = false, bool $dockerCleanup = true)
     {
         $server = $database->destination->server;
-        if (!$server->isFunctional()) {
+        if (! $server->isFunctional()) {
             return 'Server is not functional';
         }
-        instant_remote_process(
-            ["docker rm -f {$database->uuid}"],
-            $server
-        );
+
+        $this->stopContainer($database, $database->uuid, 300);
+        if (! $isDeleteOperation) {
+            if ($dockerCleanup) {
+                CleanupDocker::dispatch($server, true);
+            }
+        }
+
         if ($database->is_public) {
             StopDatabaseProxy::run($database);
         }
-        // TODO: make notification for services
-        // $database->environment->project->team->notify(new StatusChanged($database));
+
+        return 'Database stopped successfully';
+    }
+
+    private function stopContainer($database, string $containerName, int $timeout = 300): void
+    {
+        $server = $database->destination->server;
+
+        $process = Process::timeout($timeout)->start("docker stop --time=$timeout $containerName");
+
+        $startTime = time();
+        while ($process->running()) {
+            if (time() - $startTime >= $timeout) {
+                $this->forceStopContainer($containerName, $server);
+                break;
+            }
+            usleep(100000);
+        }
+
+        $this->removeContainer($containerName, $server);
+    }
+
+    private function forceStopContainer(string $containerName, $server): void
+    {
+        instant_remote_process(command: ["docker kill $containerName"], server: $server, throwError: false);
+    }
+
+    private function removeContainer(string $containerName, $server): void
+    {
+        instant_remote_process(command: ["docker rm -f $containerName"], server: $server, throwError: false);
+    }
+
+    private function deleteConnectedNetworks($uuid, $server)
+    {
+        instant_remote_process(["docker network disconnect {$uuid} coolify-proxy"], $server, false);
+        instant_remote_process(["docker network rm {$uuid}"], $server, false);
     }
 }

app/Actions/Database/StopDatabaseProxy.php

@@ -2,6 +2,7 @@
 
 namespace App\Actions\Database;
 
+use App\Events\DatabaseStatusChanged;
 use App\Models\ServiceDatabase;
 use App\Models\StandaloneClickhouse;
 use App\Models\StandaloneDragonfly;
@@ -26,7 +27,7 @@ class StopDatabaseProxy
             $server = data_get($database, 'service.server');
         }
         instant_remote_process(["docker rm -f {$uuid}-proxy"], $server);
-        $database->is_public = false;
         $database->save();
+        DatabaseStatusChanged::dispatch();
     }
 }

app/Actions/Docker/GetContainersStatus.php

@@ -12,23 +12,29 @@ 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;
 
 class GetContainersStatus
 {
     use AsAction;
+
     public $applications;
+
+    public ?Collection $containers;
+
+    public ?Collection $containerReplicates;
+
     public $server;
 
-    public function handle(Server $server)
+    public function handle(Server $server, ?Collection $containers = null, ?Collection $containerReplicates = null)
     {
-        // if (isDev()) {
-        //     $server = Server::find(0);
-        // }
+        $this->containers = $containers;
+        $this->containerReplicates = $containerReplicates;
         $this->server = $server;
-        if (!$this->server->isFunctional()) {
+        if (! $this->server->isFunctional()) {
             return 'Server is not ready.';
-        };
+        }
         $this->applications = $this->server->applications();
         $skip_these_applications = collect([]);
         foreach ($this->applications as $application) {
@@ -41,7 +47,7 @@ class GetContainersStatus
             }
         }
         $this->applications = $this->applications->filter(function ($value, $key) use ($skip_these_applications) {
-            return !$skip_these_applications->pluck('id')->contains($value->id);
+            return ! $skip_these_applications->pluck('id')->contains($value->id);
         });
         $this->old_way();
         // if ($this->server->isSwarm()) {
@@ -64,320 +70,312 @@ class GetContainersStatus
         // }
     }
 
-    private function sentinel()
-    {
-        try {
-            $containers = $this->server->getContainers();
-            if ($containers->count() === 0) {
-                return;
-            }
-            $databases = $this->server->databases();
-            $services = $this->server->services()->get();
-            $previews = $this->server->previews();
-            $foundApplications = [];
-            $foundApplicationPreviews = [];
-            $foundDatabases = [];
-            $foundServices = [];
+    // 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 ($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 = $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 = $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');
+    //         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']);
-            }
+    //             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']);
+    //         $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');
+    //             $name = data_get($application, 'name');
+    //             $fqdn = data_get($application, 'fqdn');
 
-                $containerName = $name ? "$name ($fqdn)" : $fqdn;
+    //             $containerName = $name ? "$name ($fqdn)" : $fqdn;
 
-                $projectUuid = data_get($application, 'environment.project.uuid');
-                $applicationUuid = data_get($application, 'uuid');
-                $environment = data_get($application, 'environment.name');
+    //             $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;
-                }
+    //             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']);
+    //             // $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');
+    //             $name = data_get($preview, 'name');
+    //             $fqdn = data_get($preview, 'fqdn');
 
-                $containerName = $name ? "$name ($fqdn)" : $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');
+    //             $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;
-                }
+    //             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']);
+    //             // $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');
+    //             $name = data_get($database, 'name');
+    //             $fqdn = data_get($database, 'fqdn');
 
-                $containerName = $name;
+    //             $containerName = $name;
 
-                $projectUuid = data_get($database, 'environment.project.uuid');
-                $environmentName = data_get($database, 'environment.name');
-                $databaseUuid = data_get($database, 'uuid');
+    //             $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));
-            }
+    //             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);
+    //     }
+    // }
 
-            // Check if proxy is running
-            $this->server->proxyType();
-            $foundProxyContainer = $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->server->isSwarm()) {
-            $containers = instant_remote_process(["docker service inspect $(docker service ls -q) --format '{{json .}}'"], $this->server, false);
-            $containerReplicates = instant_remote_process(["docker service ls --format '{{json .}}'"], $this->server, false);
-        } else {
-            // Precheck for containers
-            $containers = instant_remote_process(["docker container ls -q"], $this->server, false);
-            if (!$containers) {
-                return;
-            }
-            $containers = instant_remote_process(["docker container inspect $(docker container ls -q) --format '{{json .}}'"], $this->server, false);
-            $containerReplicates = null;
+        if ($this->containers === null) {
+            ['containers' => $this->containers,'containerReplicates' => $this->containerReplicates] = $this->server->getContainers();
         }
-        if (is_null($containers)) {
+
+        if (is_null($this->containers)) {
             return;
         }
 
-        $containers = format_docker_command_output_to_json($containers);
-        if ($containerReplicates) {
-            $containerReplicates = format_docker_command_output_to_json($containerReplicates);
-            foreach ($containerReplicates as $containerReplica) {
+        if ($this->containerReplicates) {
+            foreach ($this->containerReplicates as $containerReplica) {
                 $name = data_get($containerReplica, 'Name');
-                $containers = $containers->map(function ($container) use ($name, $containerReplica) {
+                $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];
@@ -390,6 +388,7 @@ class GetContainersStatus
                             data_set($container, 'State.Health.Status', 'unhealthy');
                         }
                     }
+
                     return $container;
                 });
             }
@@ -402,7 +401,7 @@ class GetContainersStatus
         $foundDatabases = [];
         $foundServices = [];
 
-        foreach ($containers as $container) {
+        foreach ($this->containers as $container) {
             if ($this->server->isSwarm()) {
                 $labels = data_get($container, 'Spec.Labels');
                 $uuid = data_get($labels, 'coolify.name');
@@ -456,14 +455,14 @@ class GetContainersStatus
                                 if ($uuid) {
                                     $isPublic = data_get($service_db, 'is_public');
                                     if ($isPublic) {
-                                        $foundTcpProxy = $containers->filter(function ($value, $key) use ($uuid) {
+                                        $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
                                             if ($this->server->isSwarm()) {
                                                 return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
                                             } else {
                                                 return data_get($value, 'Name') === "/$uuid-proxy";
                                             }
                                         })->first();
-                                        if (!$foundTcpProxy) {
+                                        if (! $foundTcpProxy) {
                                             StartDatabaseProxy::run($service_db);
                                             // $this->server->team?->notify(new ContainerRestarted("TCP Proxy for {$service_db->service->name}", $this->server));
                                         }
@@ -481,14 +480,14 @@ class GetContainersStatus
                                 $database->update(['status' => $containerStatus]);
                             }
                             if ($isPublic) {
-                                $foundTcpProxy = $containers->filter(function ($value, $key) use ($uuid) {
+                                $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
                                     if ($this->server->isSwarm()) {
                                         return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
                                     } else {
                                         return data_get($value, 'Name') === "/$uuid-proxy";
                                     }
                                 })->first();
-                                if (!$foundTcpProxy) {
+                                if (! $foundTcpProxy) {
                                     StartDatabaseProxy::run($database);
                                     $this->server->team?->notify(new ContainerRestarted("TCP Proxy for {$database->name}", $this->server));
                                 }
@@ -507,13 +506,13 @@ class GetContainersStatus
                 $subType = data_get($labels, 'coolify.service.subType');
                 $subId = data_get($labels, 'coolify.service.subId');
                 $service = $services->where('id', $serviceLabelId)->first();
-                if (!$service) {
+                if (! $service) {
                     continue;
                 }
                 if ($subType === 'application') {
-                    $service =  $service->applications()->where('id', $subId)->first();
+                    $service = $service->applications()->where('id', $subId)->first();
                 } else {
-                    $service =  $service->databases()->where('id', $subId)->first();
+                    $service = $service->databases()->where('id', $subId)->first();
                 }
                 if ($service) {
                     $foundServices[] = "$service->id-$service->name";
@@ -544,7 +543,7 @@ class GetContainersStatus
                 }
             }
         }
-        $exitedServices = $exitedServices->unique('id');
+        $exitedServices = $exitedServices->unique('uuid');
         foreach ($exitedServices as $exitedService) {
             if (str($exitedService->status)->startsWith('exited')) {
                 continue;
@@ -569,7 +568,7 @@ class GetContainersStatus
             $environmentName = data_get($service, 'environment.name');
 
             if ($projectUuid && $serviceUuid && $environmentName) {
-                $url =  base_url() . '/project/' . $projectUuid . "/" . $environmentName . "/service/" . $serviceUuid;
+                $url = base_url().'/project/'.$projectUuid.'/'.$environmentName.'/service/'.$serviceUuid;
             } else {
                 $url = null;
             }
@@ -595,7 +594,7 @@ class GetContainersStatus
             $environment = data_get($application, 'environment.name');
 
             if ($projectUuid && $applicationUuid && $environment) {
-                $url =  base_url() . '/project/' . $projectUuid . "/" . $environment . "/application/" . $applicationUuid;
+                $url = base_url().'/project/'.$projectUuid.'/'.$environment.'/application/'.$applicationUuid;
             } else {
                 $url = null;
             }
@@ -620,7 +619,7 @@ class GetContainersStatus
             $applicationUuid = data_get($preview, 'application.uuid');
 
             if ($projectUuid && $applicationUuid && $environmentName) {
-                $url =  base_url() . '/project/' . $projectUuid . "/" . $environmentName . "/application/" . $applicationUuid;
+                $url = base_url().'/project/'.$projectUuid.'/'.$environmentName.'/application/'.$applicationUuid;
             } else {
                 $url = null;
             }
@@ -645,23 +644,24 @@ class GetContainersStatus
             $databaseUuid = data_get($database, 'uuid');
 
             if ($projectUuid && $databaseUuid && $environmentName) {
-                $url = base_url() . '/project/' . $projectUuid . "/" . $environmentName . "/database/" . $databaseUuid;
+                $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 = $containers->filter(function ($value, $key) {
+        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) {
+        if (! $foundProxyContainer) {
             try {
                 $shouldStart = CheckProxy::run($this->server);
                 if ($shouldStart) {

app/Actions/Fortify/CreateNewUser.php

@@ -2,7 +2,6 @@
 
 namespace App\Actions\Fortify;
 
-use App\Models\InstanceSettings;
 use App\Models\User;
 use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Facades\Validator;
@@ -16,12 +15,12 @@ class CreateNewUser implements CreatesNewUsers
     /**
      * Validate and create a newly registered user.
      *
-     * @param array<string, string> $input
+     * @param  array<string, string>  $input
      */
     public function create(array $input): User
     {
-        $settings = InstanceSettings::get();
-        if (!$settings->is_registration_enabled) {
+        $settings = instanceSettings();
+        if (! $settings->is_registration_enabled) {
             abort(403);
         }
         Validator::make($input, [
@@ -48,7 +47,7 @@ class CreateNewUser implements CreatesNewUsers
             $team = $user->teams()->first();
 
             // Disable registration after first user is created
-            $settings = InstanceSettings::get();
+            $settings = instanceSettings();
             $settings->is_registration_enabled = false;
             $settings->save();
         } else {
@@ -66,6 +65,7 @@ class CreateNewUser implements CreatesNewUsers
         }
         // Set session variable
         session(['currentTeam' => $user->currentTeam = $team]);
+
         return $user;
     }
 }

app/Actions/Fortify/ResetUserPassword.php

@@ -14,7 +14,7 @@ class ResetUserPassword implements ResetsUserPasswords
     /**
      * Validate and reset the user's forgotten password.
      *
-     * @param array<string, string> $input
+     * @param  array<string, string>  $input
      */
     public function reset(User $user, array $input): void
     {

app/Actions/Fortify/UpdateUserPassword.php

@@ -14,7 +14,7 @@ class UpdateUserPassword implements UpdatesUserPasswords
     /**
      * Validate and update the user's password.
      *
-     * @param array<string, string> $input
+     * @param  array<string, string>  $input
      */
     public function update(User $user, array $input): void
     {

app/Actions/Fortify/UpdateUserProfileInformation.php

@@ -13,7 +13,7 @@ class UpdateUserProfileInformation implements UpdatesUserProfileInformation
     /**
      * Validate and update the given user's profile information.
      *
-     * @param array<string, string> $input
+     * @param  array<string, string>  $input
      */
     public function update(User $user, array $input): void
     {
@@ -45,7 +45,7 @@ class UpdateUserProfileInformation implements UpdatesUserProfileInformation
     /**
      * Update the given verified user's profile information.
      *
-     * @param array<string, string> $input
+     * @param  array<string, string>  $input
      */
     protected function updateVerifiedUser(User $user, array $input): void
     {

app/Actions/License/CheckResaleLicense.php

@@ -2,22 +2,22 @@
 
 namespace App\Actions\License;
 
-use App\Models\InstanceSettings;
 use Illuminate\Support\Facades\Http;
 use Lorisleiva\Actions\Concerns\AsAction;
 
-
 class CheckResaleLicense
 {
     use AsAction;
+
     public function handle()
     {
         try {
-            $settings = InstanceSettings::get();
+            $settings = instanceSettings();
             if (isDev()) {
                 $settings->update([
                     'is_resale_license_active' => true,
                 ]);
+
                 return;
             }
             // if (!$settings->resale_license) {
@@ -38,6 +38,7 @@ class CheckResaleLicense
                 $settings->update([
                     'is_resale_license_active' => true,
                 ]);
+
                 return;
             }
             $data = Http::withHeaders([
@@ -51,6 +52,7 @@ class CheckResaleLicense
                 $settings->update([
                     'is_resale_license_active' => true,
                 ]);
+
                 return;
             }
             if (data_get($data, 'license_key.status') === 'active') {

app/Actions/Proxy/CheckConfiguration.php

@@ -2,13 +2,13 @@
 
 namespace App\Actions\Proxy;
 
-use Lorisleiva\Actions\Concerns\AsAction;
 use App\Models\Server;
-use Illuminate\Support\Str;
+use Lorisleiva\Actions\Concerns\AsAction;
 
 class CheckConfiguration
 {
     use AsAction;
+
     public function handle(Server $server, bool $reset = false)
     {
         $proxyType = $server->proxyType();
@@ -21,13 +21,13 @@ class CheckConfiguration
             "cat $proxy_path/docker-compose.yml",
         ];
         $proxy_configuration = instant_remote_process($payload, $server, false);
+        if ($reset || ! $proxy_configuration || is_null($proxy_configuration)) {
+            $proxy_configuration = str(generate_default_proxy_configuration($server))->trim()->value();
+        }
+        if (! $proxy_configuration || is_null($proxy_configuration)) {
+            throw new \Exception('Could not generate proxy configuration');
+        }
 
-        if ($reset || !$proxy_configuration || is_null($proxy_configuration)) {
-            $proxy_configuration = Str::of(generate_default_proxy_configuration($server))->trim()->value;
-        }
-        if (!$proxy_configuration || is_null($proxy_configuration)) {
-            throw new \Exception("Could not generate proxy configuration");
-        }
         return $proxy_configuration;
     }
 }

app/Actions/Proxy/CheckProxy.php

@@ -2,15 +2,19 @@
 
 namespace App\Actions\Proxy;
 
+use App\Enums\ProxyTypes;
 use App\Models\Server;
 use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
 
 class CheckProxy
 {
     use AsAction;
-    public function handle(Server $server, $fromUI = false)
+
+    // It should return if the proxy should be started (true) or not (false)
+    public function handle(Server $server, $fromUI = false): bool
     {
-        if (!$server->isFunctional()) {
+        if (! $server->isFunctional()) {
             return false;
         }
         if ($server->isBuildServer()) {
@@ -18,19 +22,20 @@ class CheckProxy
                 $server->proxy = null;
                 $server->save();
             }
+
             return false;
         }
         $proxyType = $server->proxyType();
         if (is_null($proxyType) || $proxyType === 'NONE' || $server->proxy->force_stop) {
             return false;
         }
-        ['uptime' => $uptime, 'error' => $error] = $server->validateConnection();
-        if (!$uptime) {
+        ['uptime' => $uptime, 'error' => $error] = $server->validateConnection(false);
+        if (! $uptime) {
             throw new \Exception($error);
         }
-        if (!$server->isProxyShouldRun()) {
+        if (! $server->isProxyShouldRun()) {
             if ($fromUI) {
-                throw new \Exception("Proxy should not run. You selected the Custom Proxy.");
+                throw new \Exception('Proxy should not run. You selected the Custom Proxy.');
             } else {
                 return false;
             }
@@ -42,12 +47,14 @@ class CheckProxy
             if ($status === 'running') {
                 return false;
             }
+
             return true;
         } else {
             $status = getContainerStatus($server, 'coolify-proxy');
             if ($status === 'running') {
                 $server->proxy->set('status', 'running');
                 $server->save();
+
                 return false;
             }
             if ($server->settings->is_cloudflare_tunnel) {
@@ -58,24 +65,45 @@ class CheckProxy
                 $ip = 'host.docker.internal';
             }
 
-            $connection80 = @fsockopen($ip, '80');
-            $connection443 = @fsockopen($ip, '443');
-            $port80 = is_resource($connection80) && fclose($connection80);
-            $port443 = is_resource($connection443) && fclose($connection443);
-            if ($port80) {
-                if ($fromUI) {
-                    throw new \Exception("Port 80 is in use.<br>You must stop the process using this port.<br>Docs: <a target='_blank' href='https://coolify.io/docs'>https://coolify.io/docs</a><br>Discord: <a target='_blank' href='https://coollabs.io/discord'>https://coollabs.io/discord</a>");
+            $portsToCheck = ['80', '443'];
+
+            try {
+                if ($server->proxyType() !== ProxyTypes::NONE->value) {
+                    $proxyCompose = CheckConfiguration::run($server);
+                    if (isset($proxyCompose)) {
+                        $yaml = Yaml::parse($proxyCompose);
+                        $portsToCheck = [];
+                        if ($server->proxyType() === ProxyTypes::TRAEFIK->value) {
+                            $ports = data_get($yaml, 'services.traefik.ports');
+                        } elseif ($server->proxyType() === ProxyTypes::CADDY->value) {
+                            $ports = data_get($yaml, 'services.caddy.ports');
+                        }
+                        if (isset($ports)) {
+                            foreach ($ports as $port) {
+                                $portsToCheck[] = str($port)->before(':')->value();
+                            }
+                        }
+                    }
                 } else {
-                    return false;
-                }
-            }
-            if ($port443) {
-                if ($fromUI) {
-                    throw new \Exception("Port 443 is in use.<br>You must stop the process using this port.<br>Docs: <a target='_blank' href='https://coolify.io/docs'>https://coolify.io/docs</a><br>Discord: <a target='_blank' href='https://coollabs.io/discord'>https://coollabs.io/discord</a>");
-                } else {
-                    return false;
+                    $portsToCheck = [];
+                }
+            } catch (\Exception $e) {
+                ray($e->getMessage());
+            }
+            if (count($portsToCheck) === 0) {
+                return false;
+            }
+            foreach ($portsToCheck as $port) {
+                $connection = @fsockopen($ip, $port);
+                if (is_resource($connection) && fclose($connection)) {
+                    if ($fromUI) {
+                        throw new \Exception("Port $port is in use.<br>You must stop the process using this port.<br>Docs: <a target='_blank' href='https://coolify.io/docs'>https://coolify.io/docs</a><br>Discord: <a target='_blank' href='https://coollabs.io/discord'>https://coollabs.io/discord</a>");
+                    } else {
+                        return false;
+                    }
                 }
             }
+
             return true;
         }
     }

app/Actions/Proxy/SaveConfiguration.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Proxy;
 
 use App\Models\Server;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class SaveConfiguration
@@ -18,7 +17,7 @@ class SaveConfiguration
         $proxy_path = $server->proxyPath();
         $docker_compose_yml_base64 = base64_encode($proxy_settings);
 
-        $server->proxy->last_saved_settings = Str::of($docker_compose_yml_base64)->pipe('md5')->value;
+        $server->proxy->last_saved_settings = str($docker_compose_yml_base64)->pipe('md5')->value;
         $server->save();
 
         return instant_remote_process([

app/Actions/Proxy/StartProxy.php

@@ -4,29 +4,29 @@ namespace App\Actions\Proxy;
 
 use App\Events\ProxyStarted;
 use App\Models\Server;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Spatie\Activitylog\Models\Activity;
 
 class StartProxy
 {
     use AsAction;
-    public function handle(Server $server, bool $async = true): string|Activity
+
+    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()) {
+            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");
+            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::of($docker_compose_yml_base64)->pipe('md5')->value;
+            $server->proxy->last_applied_settings = str($docker_compose_yml_base64)->pipe('md5')->value();
             $server->save();
             if ($server->isSwarm()) {
                 $commands = $commands->merge([
@@ -34,11 +34,11 @@ class StartProxy
                     "cd $proxy_path",
                     "echo 'Creating required Docker Compose file.'",
                     "echo 'Starting coolify-proxy.'",
-                    "docker stack deploy -c docker-compose.yml coolify-proxy",
-                    "echo 'Proxy started successfully.'"
+                    'docker stack deploy -c docker-compose.yml coolify-proxy',
+                    "echo 'Successfully started coolify-proxy.'",
                 ]);
             } else {
-                $caddfile = "import /dynamic/*.caddy";
+                $caddfile = 'import /dynamic/*.caddy';
                 $commands = $commands->merge([
                     "mkdir -p $proxy_path/dynamic",
                     "cd $proxy_path",
@@ -46,17 +46,21 @@ class StartProxy
                     "echo 'Creating required Docker Compose file.'",
                     "echo 'Pulling docker image.'",
                     'docker compose pull',
-                    "echo 'Stopping existing coolify-proxy.'",
-                    "docker compose down -v --remove-orphans > /dev/null 2>&1",
+                    '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 'Proxy started successfully.'"
+                    "echo 'Successfully started coolify-proxy.'",
                 ]);
                 $commands = $commands->merge(connectProxyToNetworks($server));
             }
 
             if ($async) {
                 $activity = remote_process($commands, $server, callEventOnFinish: 'ProxyStarted', callEventData: $server);
+
                 return $activity;
             } else {
                 instant_remote_process($commands, $server);
@@ -64,6 +68,7 @@ class StartProxy
                 $server->proxy->set('type', $proxyType);
                 $server->save();
                 ProxyStarted::dispatch($server);
+
                 return 'OK';
             }
         } catch (\Throwable $e) {

app/Actions/Server/CleanupDocker.php

@@ -2,22 +2,38 @@
 
 namespace App\Actions\Server;
 
-use Lorisleiva\Actions\Concerns\AsAction;
 use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
 
 class CleanupDocker
 {
     use AsAction;
-    public function handle(Server $server, bool $force = true)
+
+    public function handle(Server $server)
     {
-        if ($force) {
-            instant_remote_process(['docker image prune -af'], $server, false);
-            instant_remote_process(['docker container prune -f --filter "label=coolify.managed=true"'], $server, false);
-            instant_remote_process(['docker builder prune -af'], $server, false);
-        } else {
-            instant_remote_process(['docker image prune -f'], $server, false);
-            instant_remote_process(['docker container prune -f --filter "label=coolify.managed=true"'], $server, false);
-            instant_remote_process(['docker builder prune -f'], $server, false);
+        $settings = instanceSettings();
+        $helperImageVersion = data_get($settings, 'helper_version');
+        $helperImage = config('coolify.helper_image');
+        $helperImageWithVersion = "$helperImage:$helperImageVersion";
+
+        $commands = [
+            'docker container prune -f --filter "label=coolify.managed=true" --filter "label!=coolify.proxy=true"',
+            'docker image prune -af --filter "label!=coolify.managed=true"',
+            'docker builder prune -af',
+            "docker images --filter before=$helperImageWithVersion --filter reference=$helperImage | grep $helperImage | awk '{print $3}' | xargs -r docker rmi -f",
+        ];
+
+        $serverSettings = $server->settings;
+        if ($serverSettings->delete_unused_volumes) {
+            $commands[] = 'docker volume prune -af';
+        }
+
+        if ($serverSettings->delete_unused_networks) {
+            $commands[] = 'docker network prune -f';
+        }
+
+        foreach ($commands as $command) {
+            instant_remote_process([$command], $server, false);
         }
     }
 }

app/Actions/Server/ConfigureCloudflared.php

@@ -2,6 +2,7 @@
 
 namespace App\Actions\Server;
 
+use App\Events\CloudflareTunnelConfigured;
 use App\Models\Server;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
@@ -9,18 +10,19 @@ use Symfony\Component\Yaml\Yaml;
 class ConfigureCloudflared
 {
     use AsAction;
+
     public function handle(Server $server, string $cloudflare_token)
     {
         try {
             $config = [
-                "services" => [
-                    "coolify-cloudflared" => [
-                        "container_name" => "coolify-cloudflared",
-                        "image" => "cloudflare/cloudflared:latest",
-                        "restart" => RESTART_MODE,
-                        "network_mode" => "host",
-                        "command" => "tunnel run",
-                        "environment" => [
+                'services' => [
+                    'coolify-cloudflared' => [
+                        'container_name' => 'coolify-cloudflared',
+                        'image' => 'cloudflare/cloudflared:latest',
+                        'restart' => RESTART_MODE,
+                        'network_mode' => 'host',
+                        'command' => 'tunnel run',
+                        'environment' => [
                             "TUNNEL_TOKEN={$cloudflare_token}",
                         ],
                     ],
@@ -29,22 +31,27 @@ class ConfigureCloudflared
             $config = Yaml::dump($config, 12, 2);
             $docker_compose_yml_base64 = base64_encode($config);
             $commands = collect([
-                "mkdir -p /tmp/cloudflared",
-                "cd /tmp/cloudflared",
+                'mkdir -p /tmp/cloudflared',
+                'cd /tmp/cloudflared',
                 "echo '$docker_compose_yml_base64' | base64 -d | tee docker-compose.yml > /dev/null",
-                "docker compose pull",
-                "docker compose down -v --remove-orphans > /dev/null 2>&1",
-                "docker compose up -d --remove-orphans",
+                'docker compose pull',
+                'docker compose down -v --remove-orphans > /dev/null 2>&1',
+                'docker compose up -d --remove-orphans',
             ]);
             instant_remote_process($commands, $server);
         } catch (\Throwable $e) {
             ray($e);
+            $server->settings->is_cloudflare_tunnel = false;
+            $server->settings->save();
             throw $e;
         } finally {
+            CloudflareTunnelConfigured::dispatch($server->team_id);
+
             $commands = collect([
-                "rm -fr /tmp/cloudflared",
+                'rm -fr /tmp/cloudflared',
             ]);
             instant_remote_process($commands, $server);
+
         }
     }
 }

app/Actions/Server/InstallDocker.php

@@ -2,20 +2,21 @@
 
 namespace App\Actions\Server;
 
-use Lorisleiva\Actions\Concerns\AsAction;
 use App\Models\Server;
 use App\Models\StandaloneDocker;
+use Lorisleiva\Actions\Concerns\AsAction;
 
 class InstallDocker
 {
     use AsAction;
+
     public function handle(Server $server)
     {
         $supported_os_type = $server->validateOS();
-        if (!$supported_os_type) {
+        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);
+        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",
@@ -36,40 +37,41 @@ class InstallDocker
         if (isDev() && $server->id === 0) {
             $command = $command->merge([
                 "echo 'Installing Prerequisites...'",
-                "sleep 1",
+                'sleep 1',
                 "echo 'Installing Docker Engine...'",
                 "echo 'Configuring Docker Engine (merging existing configuration with the required)...'",
-                "sleep 4",
+                'sleep 4',
                 "echo 'Restarting Docker Engine...'",
-                "ls -l /tmp"
+                'ls -l /tmp',
             ]);
+
             return remote_process($command, $server);
         } else {
             if ($supported_os_type->contains('debian')) {
                 $command = $command->merge([
                     "echo 'Installing Prerequisites...'",
-                    "apt-get update -y",
-                    "command -v curl >/dev/null || apt install -y curl",
-                    "command -v wget >/dev/null || apt install -y wget",
-                    "command -v git >/dev/null || apt install -y git",
-                    "command -v jq >/dev/null || apt install -y jq",
+                    'apt-get update -y',
+                    'command -v curl >/dev/null || apt install -y curl',
+                    'command -v wget >/dev/null || apt install -y wget',
+                    'command -v git >/dev/null || apt install -y git',
+                    'command -v jq >/dev/null || apt install -y jq',
                 ]);
-            } else if ($supported_os_type->contains('rhel')) {
+            } elseif ($supported_os_type->contains('rhel')) {
                 $command = $command->merge([
                     "echo 'Installing Prerequisites...'",
-                    "command -v curl >/dev/null || dnf install -y curl",
-                    "command -v wget >/dev/null || dnf install -y wget",
-                    "command -v git >/dev/null || dnf install -y git",
-                    "command -v jq >/dev/null || dnf install -y jq",
+                    'command -v curl >/dev/null || dnf install -y curl',
+                    'command -v wget >/dev/null || dnf install -y wget',
+                    'command -v git >/dev/null || dnf install -y git',
+                    'command -v jq >/dev/null || dnf install -y jq',
                 ]);
-            } else if ($supported_os_type->contains('sles')) {
+            } elseif ($supported_os_type->contains('sles')) {
                 $command = $command->merge([
                     "echo 'Installing Prerequisites...'",
-                    "zypper update -y",
-                    "command -v curl >/dev/null || zypper install -y curl",
-                    "command -v wget >/dev/null || zypper install -y wget",
-                    "command -v git >/dev/null || zypper install -y git",
-                    "command -v jq >/dev/null || zypper install -y jq",
+                    'zypper update -y',
+                    'command -v curl >/dev/null || zypper install -y curl',
+                    'command -v wget >/dev/null || zypper install -y wget',
+                    'command -v git >/dev/null || zypper install -y git',
+                    'command -v jq >/dev/null || zypper install -y jq',
                 ]);
             } else {
                 throw new \Exception('Unsupported OS');
@@ -78,29 +80,30 @@ class InstallDocker
                 "echo 'Installing Docker Engine...'",
                 "curl https://releases.rancher.com/install-docker/{$dockerVersion}.sh | sh || curl https://get.docker.com | sh -s -- --version {$dockerVersion}",
                 "echo 'Configuring Docker Engine (merging existing configuration with the required)...'",
-                "test -s /etc/docker/daemon.json && cp /etc/docker/daemon.json \"/etc/docker/daemon.json.original-$(date +\"%Y%m%d-%H%M%S\")\"",
+                'test -s /etc/docker/daemon.json && cp /etc/docker/daemon.json "/etc/docker/daemon.json.original-$(date +"%Y%m%d-%H%M%S")"',
                 "test ! -s /etc/docker/daemon.json && echo '{$config}' | base64 -d | tee /etc/docker/daemon.json > /dev/null",
                 "echo '{$config}' | base64 -d | tee /etc/docker/daemon.json.coolify > /dev/null",
-                "jq . /etc/docker/daemon.json.coolify | tee /etc/docker/daemon.json.coolify.pretty > /dev/null",
-                "mv /etc/docker/daemon.json.coolify.pretty /etc/docker/daemon.json.coolify",
+                'jq . /etc/docker/daemon.json.coolify | tee /etc/docker/daemon.json.coolify.pretty > /dev/null',
+                'mv /etc/docker/daemon.json.coolify.pretty /etc/docker/daemon.json.coolify',
                 "jq -s '.[0] * .[1]' /etc/docker/daemon.json.coolify /etc/docker/daemon.json | tee /etc/docker/daemon.json.appended > /dev/null",
-                "mv /etc/docker/daemon.json.appended /etc/docker/daemon.json",
+                'mv /etc/docker/daemon.json.appended /etc/docker/daemon.json',
                 "echo 'Restarting Docker Engine...'",
-                "systemctl enable docker >/dev/null 2>&1 || true",
-                "systemctl restart docker",
+                'systemctl enable docker >/dev/null 2>&1 || true',
+                'systemctl restart docker',
             ]);
             if ($server->isSwarm()) {
                 $command = $command->merge([
-                    "docker network create --attachable --driver overlay coolify-overlay >/dev/null 2>&1 || true",
+                    'docker network create --attachable --driver overlay coolify-overlay >/dev/null 2>&1 || true',
                 ]);
             } else {
                 $command = $command->merge([
-                    "docker network create --attachable coolify >/dev/null 2>&1 || true",
+                    'docker network create --attachable coolify >/dev/null 2>&1 || true',
                 ]);
                 $command = $command->merge([
                     "echo 'Done!'",
                 ]);
             }
+
             return remote_process($command, $server);
         }
     }

app/Actions/Server/InstallLogDrain.php

@@ -2,34 +2,31 @@
 
 namespace App\Actions\Server;
 
-use Lorisleiva\Actions\Concerns\AsAction;
 use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
 
 class InstallLogDrain
 {
     use AsAction;
+
     public function handle(Server $server)
     {
         if ($server->settings->is_logdrain_newrelic_enabled) {
             $type = 'newrelic';
-        } else if ($server->settings->is_logdrain_highlight_enabled) {
+        } elseif ($server->settings->is_logdrain_highlight_enabled) {
             $type = 'highlight';
-        } else if ($server->settings->is_logdrain_axiom_enabled) {
+        } elseif ($server->settings->is_logdrain_axiom_enabled) {
             $type = 'axiom';
-        } else if ($server->settings->is_logdrain_custom_enabled) {
+        } elseif ($server->settings->is_logdrain_custom_enabled) {
             $type = 'custom';
         } else {
             $type = 'none';
         }
         try {
             if ($type === 'none') {
-                $command = [
-                    "echo 'Stopping old Fluent Bit'",
-                    "docker rm -f coolify-log-drain || true",
-                ];
-                return instant_remote_process($command, $server);
-            } else if ($type === 'newrelic') {
-                if (!$server->settings->is_logdrain_newrelic_enabled) {
+                return 'No log drain is enabled.';
+            } elseif ($type === 'newrelic') {
+                if (! $server->settings->is_logdrain_newrelic_enabled) {
                     throw new \Exception('New Relic log drain is not enabled.');
                 }
                 $config = base64_encode("
@@ -50,7 +47,11 @@ class InstallLogDrain
 [FILTER]
     Name                modify
     Match               *
-    Set                 server_name {$server->name}
+    Set                 coolify.server_name {$server->name}
+    Rename              COOLIFY_APP_NAME coolify.app_name
+    Rename              COOLIFY_PROJECT_NAME coolify.project_name
+    Rename              COOLIFY_SERVER_IP coolify.server_ip
+    Rename              COOLIFY_ENVIRONMENT_NAME coolify.environment_name
 [OUTPUT]
     Name nrlogs
     Match *
@@ -59,11 +60,11 @@ class InstallLogDrain
     # https://log-api.newrelic.com/log/v1 - US
     base_uri \${BASE_URI}
 ");
-            } else if ($type === 'highlight') {
-                if (!$server->settings->is_logdrain_highlight_enabled) {
+            } elseif ($type === 'highlight') {
+                if (! $server->settings->is_logdrain_highlight_enabled) {
                     throw new \Exception('Highlight log drain is not enabled.');
                 }
-                $config = base64_encode("
+                $config = base64_encode('
 [SERVICE]
     Flush     5
     Daemon    off
@@ -71,7 +72,7 @@ class InstallLogDrain
     Parsers_File  parsers.conf
 [INPUT]
     Name              forward
-    tag               \${HIGHLIGHT_PROJECT_ID}
+    tag               ${HIGHLIGHT_PROJECT_ID}
     Buffer_Chunk_Size 1M
     Buffer_Max_Size   6M
 [OUTPUT]
@@ -79,9 +80,9 @@ class InstallLogDrain
     Match               *
     Host                otel.highlight.io
     Port                24224
-");
-            } else if ($type === 'axiom') {
-                if (!$server->settings->is_logdrain_axiom_enabled) {
+');
+            } elseif ($type === 'axiom') {
+                if (! $server->settings->is_logdrain_axiom_enabled) {
                     throw new \Exception('Axiom log drain is not enabled.');
                 }
                 $config = base64_encode("
@@ -101,7 +102,11 @@ class InstallLogDrain
 [FILTER]
     Name                modify
     Match               *
-    Set                 server_name {$server->name}
+    Set                 coolify.server_name {$server->name}
+    Rename              COOLIFY_APP_NAME coolify.app_name
+    Rename              COOLIFY_PROJECT_NAME coolify.project_name
+    Rename              COOLIFY_SERVER_IP coolify.server_ip
+    Rename              COOLIFY_ENVIRONMENT_NAME coolify.environment_name
 [OUTPUT]
     Name            http
     Match           *
@@ -116,8 +121,8 @@ class InstallLogDrain
     json_date_format iso8601
     tls On
 ");
-            } else if ($type === 'custom') {
-                if (!$server->settings->is_logdrain_custom_enabled) {
+            } elseif ($type === 'custom') {
+                if (! $server->settings->is_logdrain_custom_enabled) {
                     throw new \Exception('Custom log drain is not enabled.');
                 }
                 $config = base64_encode($server->settings->logdrain_custom_config);
@@ -133,7 +138,7 @@ class InstallLogDrain
     Regex       /^(?!\s*$).+/
 ");
             }
-            $compose = base64_encode("
+            $compose = base64_encode('
 services:
   coolify-log-drain:
     image: cr.fluentbit.io/fluent/fluent-bit:2.0
@@ -147,7 +152,7 @@ services:
     ports:
       - 127.0.0.1:24224:24224
     restart: unless-stopped
-");
+');
             $readme = base64_encode('# New Relic Log Drain
 This log drain is based on [Fluent Bit](https://fluentbit.io/) and New Relic Log Forwarder.
 
@@ -160,11 +165,11 @@ Files:
             $base_uri = $server->settings->logdrain_newrelic_base_uri;
             $base_path = config('coolify.base_config_path');
 
-            $config_path = $base_path . '/log-drains';
-            $fluent_bit_config = $config_path . '/fluent-bit.conf';
-            $parsers_config = $config_path . '/parsers.conf';
-            $compose_path = $config_path . '/docker-compose.yml';
-            $readme_path = $config_path . '/README.md';
+            $config_path = $base_path.'/log-drains';
+            $fluent_bit_config = $config_path.'/fluent-bit.conf';
+            $parsers_config = $config_path.'/parsers.conf';
+            $compose_path = $config_path.'/docker-compose.yml';
+            $readme_path = $config_path.'/README.md';
             $command = [
                 "echo 'Saving configuration'",
                 "mkdir -p $config_path",
@@ -180,18 +185,18 @@ Files:
                     "echo LICENSE_KEY=$license_key >> $config_path/.env",
                     "echo BASE_URI=$base_uri >> $config_path/.env",
                 ];
-            } else if ($type === 'highlight') {
+            } elseif ($type === 'highlight') {
                 $add_envs_command = [
                     "echo HIGHLIGHT_PROJECT_ID={$server->settings->logdrain_highlight_project_id} >> $config_path/.env",
                 ];
-            } else if ($type === 'axiom') {
+            } elseif ($type === 'axiom') {
                 $add_envs_command = [
                     "echo AXIOM_DATASET_NAME={$server->settings->logdrain_axiom_dataset_name} >> $config_path/.env",
                     "echo AXIOM_API_KEY={$server->settings->logdrain_axiom_api_key} >> $config_path/.env",
                 ];
-            } else if ($type === 'custom') {
+            } elseif ($type === 'custom') {
                 $add_envs_command = [
-                    "touch $config_path/.env"
+                    "touch $config_path/.env",
                 ];
             } else {
                 throw new \Exception('Unknown log drain type.');
@@ -203,6 +208,7 @@ Files:
                 "cd $config_path && docker compose up -d --remove-orphans",
             ];
             $command = array_merge($command, $add_envs_command, $restart_command);
+
             return instant_remote_process($command, $server);
         } catch (\Throwable $e) {
             return handleError($e);

app/Actions/Server/RunCommand.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Enums\ActivityTypes;
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class RunCommand
+{
+    use AsAction;
+
+    public function handle(Server $server, $command)
+    {
+        $activity = remote_process(command: [$command], server: $server, ignore_errors: true, type: ActivityTypes::COMMAND->value);
+
+        return $activity;
+    }
+}

app/Actions/Server/StartSentinel.php

@@ -2,21 +2,25 @@
 
 namespace App\Actions\Server;
 
-use Lorisleiva\Actions\Concerns\AsAction;
 use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
 
 class StartSentinel
 {
     use AsAction;
+
     public function handle(Server $server, $version = 'latest', bool $restart = false)
     {
         if ($restart) {
-            instant_remote_process(['docker rm -f coolify-sentinel'], $server, false);
+            StopSentinel::run($server);
         }
+        $metrics_history = $server->settings->metrics_history_days;
+        $refresh_rate = $server->settings->metrics_refresh_rate_seconds;
+        $token = $server->settings->metrics_token;
         instant_remote_process([
-            "docker run --rm --pull always -d -e \"SCHEDULER=true\" --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, false);
+            "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);
     }
 }

app/Actions/Server/StopLogDrain.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class StopLogDrain
+{
+    use AsAction;
+
+    public function handle(Server $server)
+    {
+        try {
+            return instant_remote_process(['docker rm -f coolify-log-drain || true'], $server);
+        } catch (\Throwable $e) {
+            return handleError($e);
+        }
+    }
+}

app/Actions/Server/StopSentinel.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class StopSentinel
+{
+    use AsAction;
+
+    public function handle(Server $server)
+    {
+        instant_remote_process(['docker rm -f coolify-sentinel'], $server, false);
+    }
+}

app/Actions/Server/UpdateCoolify.php

@@ -2,31 +2,33 @@
 
 namespace App\Actions\Server;
 
-use Lorisleiva\Actions\Concerns\AsAction;
-use App\Models\InstanceSettings;
+use App\Jobs\PullHelperImageJob;
 use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
 
 class UpdateCoolify
 {
     use AsAction;
+
     public ?Server $server = null;
+
     public ?string $latestVersion = null;
+
     public ?string $currentVersion = null;
 
     public function handle($manual_update = false)
     {
         try {
-            $settings = InstanceSettings::get();
-            ray('Running InstanceAutoUpdateJob');
+            $settings = instanceSettings();
             $this->server = Server::find(0);
-            if (!$this->server) {
+            if (! $this->server) {
                 return;
             }
-            CleanupDocker::run($this->server, false);
+            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) {
+            if (! $manual_update) {
+                if (! $settings->is_auto_update_enabled) {
                     return;
                 }
                 if ($this->latestVersion === $this->currentVersion) {
@@ -37,6 +39,8 @@ class UpdateCoolify
                 }
             }
             $this->update();
+            $settings->new_version_available = false;
+            $settings->save();
         } catch (\Throwable $e) {
             throw $e;
         }
@@ -46,14 +50,23 @@ class UpdateCoolify
     {
         if (isDev()) {
             remote_process([
-                "sleep 10"
+                '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);
+        }
+
+        instant_remote_process(["docker pull -q ghcr.io/coollabsio/coolify:{$this->latestVersion}"], $this->server, false);
+
         remote_process([
-            "curl -fsSL https://cdn.coollabs.io/coolify/upgrade.sh -o /data/coolify/source/upgrade.sh",
-            "bash /data/coolify/source/upgrade.sh $this->latestVersion"
+            'curl -fsSL https://cdn.coollabs.io/coolify/upgrade.sh -o /data/coolify/source/upgrade.sh',
+            "bash /data/coolify/source/upgrade.sh $this->latestVersion",
         ], $this->server);
-        return;
     }
 }

app/Actions/Server/ValidateServer.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class ValidateServer
+{
+    use AsAction;
+
+    public ?string $uptime = null;
+
+    public ?string $error = null;
+
+    public ?string $supported_os_type = null;
+
+    public ?string $docker_installed = null;
+
+    public ?string $docker_compose_installed = null;
+
+    public ?string $docker_version = null;
+
+    public function handle(Server $server)
+    {
+        $server->update([
+            'validation_logs' => null,
+        ]);
+        ['uptime' => $this->uptime, 'error' => $error] = $server->validateConnection();
+        if (! $this->uptime) {
+            $this->error = 'Server is not reachable. Please validate your configuration and connection.<br>Check this <a target="_blank" class="text-black underline dark:text-white" href="https://coolify.io/docs/knowledge-base/server/openssh">documentation</a> for further help. <br><br><div class="text-error">Error: '.$error.'</div>';
+            $server->update([
+                'validation_logs' => $this->error,
+            ]);
+            throw new \Exception($this->error);
+        }
+        $this->supported_os_type = $server->validateOS();
+        if (! $this->supported_os_type) {
+            $this->error = 'Server OS type is not supported. Please install Docker manually before continuing: <a target="_blank" class="text-black underline dark:text-white" href="https://docs.docker.com/engine/install/#server">documentation</a>.';
+            $server->update([
+                'validation_logs' => $this->error,
+            ]);
+            throw new \Exception($this->error);
+        }
+
+        $this->docker_installed = $server->validateDockerEngine();
+        $this->docker_compose_installed = $server->validateDockerCompose();
+        if (! $this->docker_installed || ! $this->docker_compose_installed) {
+            $this->error = 'Docker Engine is not installed. Please install Docker manually before continuing: <a target="_blank" class="text-black underline dark:text-white" href="https://docs.docker.com/engine/install/#server">documentation</a>.';
+            $server->update([
+                'validation_logs' => $this->error,
+            ]);
+            throw new \Exception($this->error);
+        }
+        $this->docker_version = $server->validateDockerEngineVersion();
+
+        if ($this->docker_version) {
+            return 'OK';
+        } else {
+            $this->error = 'Docker Engine is not installed. Please install Docker manually before continuing: <a target="_blank" class="text-black underline dark:text-white" href="https://docs.docker.com/engine/install/#server">documentation</a>.';
+            $server->update([
+                'validation_logs' => $this->error,
+            ]);
+            throw new \Exception($this->error);
+        }
+    }
+}

app/Actions/Service/DeleteService.php

@@ -2,17 +2,19 @@
 
 namespace App\Actions\Service;
 
-use Lorisleiva\Actions\Concerns\AsAction;
+use App\Actions\Server\CleanupDocker;
 use App\Models\Service;
+use Lorisleiva\Actions\Concerns\AsAction;
 
 class DeleteService
 {
     use AsAction;
-    public function handle(Service $service)
+
+    public function handle(Service $service, bool $deleteConfigurations, bool $deleteVolumes, bool $dockerCleanup, bool $deleteConnectedNetworks)
     {
         try {
             $server = data_get($service, 'server');
-            if ($server->isFunctional()) {
+            if ($deleteVolumes && $server->isFunctional()) {
                 $storagesToDelete = collect([]);
 
                 $service->environment_variables()->delete();
@@ -32,13 +34,29 @@ class DeleteService
                 foreach ($storagesToDelete as $storage) {
                     $commands[] = "docker volume rm -f $storage->name";
                 }
-                $commands[] = "docker rm -f $service->uuid";
 
-                instant_remote_process($commands, $server, false);
+                // Execute volume deletion first, this must be done first otherwise volumes will not be deleted.
+                if (! empty($commands)) {
+                    foreach ($commands as $command) {
+                        $result = instant_remote_process([$command], $server, false);
+                        if ($result !== 0) {
+                            ray("Failed to execute: $command");
+                        }
+                    }
+                }
             }
+
+            if ($deleteConnectedNetworks) {
+                $service->delete_connected_networks($service->uuid);
+            }
+
+            instant_remote_process(["docker rm -f $service->uuid"], $server, throwError: false);
         } catch (\Exception $e) {
             throw new \Exception($e->getMessage());
         } finally {
+            if ($deleteConfigurations) {
+                $service->delete_configurations();
+            }
             foreach ($service->applications()->get() as $application) {
                 $application->forceDelete();
             }
@@ -49,6 +67,11 @@ class DeleteService
                 $task->delete();
             }
             $service->tags()->detach();
+            $service->forceDelete();
+
+            if ($dockerCleanup) {
+                CleanupDocker::dispatch($server, true);
+            }
         }
     }
 }

app/Actions/Service/RestartService.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Actions\Service;
+
+use App\Models\Service;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class RestartService
+{
+    use AsAction;
+
+    public function handle(Service $service)
+    {
+        StopService::run($service);
+
+        return StartService::run($service);
+    }
+}

app/Actions/Service/StartService.php

@@ -2,36 +2,40 @@
 
 namespace App\Actions\Service;
 
-use Lorisleiva\Actions\Concerns\AsAction;
 use App\Models\Service;
+use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
 class StartService
 {
     use AsAction;
+
     public function handle(Service $service)
     {
-        ray('Starting service: ' . $service->name);
+        ray('Starting service: '.$service->name);
         $service->saveComposeConfigs();
-        $commands[] = "cd " . $service->workdir();
+        $commands[] = 'cd '.$service->workdir();
         $commands[] = "echo 'Saved configuration files to {$service->workdir()}.'";
-        $commands[] = "echo 'Creating Docker network.'";
-        $commands[] = "docker network inspect $service->uuid >/dev/null 2>&1 || docker network create --attachable $service->uuid";
-        $commands[] = "echo Starting service.";
+        if ($service->networks()->count() > 0) {
+            $commands[] = "echo 'Creating Docker network.'";
+            $commands[] = "docker network inspect $service->uuid >/dev/null 2>&1 || docker network create --attachable $service->uuid";
+        }
+        $commands[] = 'echo Starting service.';
         $commands[] = "echo 'Pulling images.'";
-        $commands[] = "docker compose pull";
+        $commands[] = 'docker compose pull';
         $commands[] = "echo 'Starting containers.'";
-        $commands[] = "docker compose up -d --remove-orphans --force-recreate --build";
+        $commands[] = 'docker compose up -d --remove-orphans --force-recreate --build';
         $commands[] = "docker network connect $service->uuid coolify-proxy >/dev/null 2>&1 || true";
         if (data_get($service, 'connect_to_docker_network')) {
             $compose = data_get($service, 'docker_compose', []);
             $network = $service->destination->network;
             $serviceNames = data_get(Yaml::parse($compose), 'services', []);
             foreach ($serviceNames as $serviceName => $serviceConfig) {
-                $commands[] = "docker network connect --alias {$serviceName}-{$service->uuid} $network {$serviceName}-{$service->uuid} || true";
+                $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;
     }
 }

app/Actions/Service/StopService.php

@@ -2,39 +2,35 @@
 
 namespace App\Actions\Service;
 
-use Lorisleiva\Actions\Concerns\AsAction;
+use App\Actions\Server\CleanupDocker;
 use App\Models\Service;
+use Lorisleiva\Actions\Concerns\AsAction;
 
 class StopService
 {
     use AsAction;
-    public function handle(Service $service)
+
+    public function handle(Service $service, bool $isDeleteOperation = false, bool $dockerCleanup = true)
     {
         try {
             $server = $service->destination->server;
-            if (!$server->isFunctional()) {
+            if (! $server->isFunctional()) {
                 return 'Server is not functional';
             }
-            ray('Stopping service: ' . $service->name);
-            $applications = $service->applications()->get();
-            foreach ($applications as $application) {
-                instant_remote_process(["docker rm -f {$application->name}-{$service->uuid}"], $service->server);
-                $application->update(['status' => 'exited']);
+
+            $containersToStop = $service->getContainersToStop();
+            $service->stopContainers($containersToStop, $server);
+
+            if (! $isDeleteOperation) {
+                $service->delete_connected_networks($service->uuid);
+                if ($dockerCleanup) {
+                    CleanupDocker::dispatch($server, true);
+                }
             }
-            $dbs = $service->databases()->get();
-            foreach ($dbs as $db) {
-                instant_remote_process(["docker rm -f {$db->name}-{$service->uuid}"], $service->server);
-                $db->update(['status' => 'exited']);
-            }
-            instant_remote_process(["docker network disconnect {$service->uuid} coolify-proxy 2>/dev/null"], $service->server, false);
-            instant_remote_process(["docker network rm {$service->uuid} 2>/dev/null"], $service->server, false);
-            // TODO: make notification for databases
-            // $service->environment->project->team->notify(new StatusChanged($service));
         } catch (\Exception $e) {
-            echo $e->getMessage();
             ray($e->getMessage());
+
             return $e->getMessage();
         }
-
     }
 }

app/Actions/Shared/ComplexStatusCheck.php

@@ -8,18 +8,21 @@ use Lorisleiva\Actions\Concerns\AsAction;
 class ComplexStatusCheck
 {
     use AsAction;
+
     public function handle(Application $application)
     {
         $servers = $application->additional_servers;
         $servers->push($application->destination->server);
         foreach ($servers as $server) {
             $is_main_server = $application->destination->server->id === $server->id;
-            if (!$server->isFunctional()) {
+            if (! $server->isFunctional()) {
                 if ($is_main_server) {
                     $application->update(['status' => 'exited:unhealthy']);
+
                     continue;
                 } else {
                     $application->additional_servers()->updateExistingPivot($server->id, ['status' => 'exited:unhealthy']);
+
                     continue;
                 }
             }
@@ -44,9 +47,11 @@ class ComplexStatusCheck
             } else {
                 if ($is_main_server) {
                     $application->update(['status' => 'exited:unhealthy']);
+
                     continue;
                 } else {
                     $application->additional_servers()->updateExistingPivot($server->id, ['status' => 'exited:unhealthy']);
+
                     continue;
                 }
             }

app/Actions/Shared/PullImage.php

@@ -8,17 +8,20 @@ use Lorisleiva\Actions\Concerns\AsAction;
 class PullImage
 {
     use AsAction;
+
     public function handle(Service $resource)
     {
         $resource->saveComposeConfigs();
 
-        $commands[] = "cd " . $resource->workdir();
+        $commands[] = 'cd '.$resource->workdir();
         $commands[] = "echo 'Saved configuration files to {$resource->workdir()}.'";
-        $commands[] = "docker compose pull";
+        $commands[] = 'docker compose pull';
 
         $server = data_get($resource, 'server');
 
-        if (!$server) return;
+        if (! $server) {
+            return;
+        }
 
         instant_remote_process($commands, $resource->server);
     }

app/Console/Commands/AdminRemoveUser.php

@@ -2,7 +2,6 @@
 
 namespace App\Console\Commands;
 
-use App\Models\Server;
 use App\Models\User;
 use Illuminate\Console\Command;
 
@@ -29,9 +28,10 @@ class AdminRemoveUser extends Command
     {
         try {
             $email = $this->argument('email');
-            $confirm = $this->confirm('Are you sure you want to remove user with email: ' . $email . '?');
-            if (!$confirm) {
+            $confirm = $this->confirm('Are you sure you want to remove user with email: '.$email.'?');
+            if (! $confirm) {
                 $this->info('User removal cancelled.');
+
                 return;
             }
             $this->info("Removing user with email: $email");
@@ -40,6 +40,7 @@ class AdminRemoveUser extends Command
             foreach ($teams as $team) {
                 if ($team->members->count() > 1) {
                     $this->error('User is a member of a team with more than one member. Please remove user from team first.');
+
                     return;
                 }
                 $team->delete();
@@ -48,6 +49,7 @@ class AdminRemoveUser extends Command
         } catch (\Exception $e) {
             $this->error('Failed to remove user.');
             $this->error($e->getMessage());
+
             return;
         }
     }

app/Console/Commands/CheckApplicationDeploymentQueue.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Enums\ApplicationDeploymentStatus;
+use App\Models\ApplicationDeploymentQueue;
+use Illuminate\Console\Command;
+
+class CheckApplicationDeploymentQueue extends Command
+{
+    protected $signature = 'check:deployment-queue {--force} {--seconds=3600}';
+
+    protected $description = 'Check application deployment queue.';
+
+    public function handle()
+    {
+        $seconds = $this->option('seconds');
+        $deployments = ApplicationDeploymentQueue::whereIn('status', [
+            ApplicationDeploymentStatus::IN_PROGRESS,
+            ApplicationDeploymentStatus::QUEUED,
+        ])->where('created_at', '<=', now()->subSeconds($seconds))->get();
+        if ($deployments->isEmpty()) {
+            $this->info('No deployments found in the last '.$seconds.' seconds.');
+
+            return;
+        }
+
+        $this->info('Found '.$deployments->count().' deployments created in the last '.$seconds.' seconds.');
+
+        foreach ($deployments as $deployment) {
+            if ($this->option('force')) {
+                $this->info('Deployment '.$deployment->id.' created at '.$deployment->created_at.' is older than '.$seconds.' seconds. Setting status to failed.');
+                $this->cancelDeployment($deployment);
+            } else {
+                $this->info('Deployment '.$deployment->id.' created at '.$deployment->created_at.' is older than '.$seconds.' seconds. Setting status to failed.');
+                if ($this->confirm('Do you want to cancel this deployment?', true)) {
+                    $this->cancelDeployment($deployment);
+                }
+            }
+        }
+    }
+
+    private function cancelDeployment(ApplicationDeploymentQueue $deployment)
+    {
+        $deployment->update(['status' => ApplicationDeploymentStatus::FAILED]);
+        if ($deployment->server?->isFunctional()) {
+            remote_process(['docker rm -f '.$deployment->deployment_uuid], $deployment->server, false);
+        }
+    }
+}

app/Console/Commands/CleanupApplicationDeploymentQueue.php

@@ -7,18 +7,19 @@ use Illuminate\Console\Command;
 
 class CleanupApplicationDeploymentQueue extends Command
 {
-    protected $signature = 'cleanup:application-deployment-queue {--team-id=}';
-    protected $description = 'CleanupApplicationDeploymentQueue';
+    protected $signature = 'cleanup:deployment-queue {--team-id=}';
+
+    protected $description = 'Cleanup application deployment queue.';
 
     public function handle()
     {
         $team_id = $this->option('team-id');
         $servers = \App\Models\Server::where('team_id', $team_id)->get();
         foreach ($servers as $server) {
-            $deployments = ApplicationDeploymentQueue::whereIn("status", ["in_progress", "queued"])->where("server_id", $server->id)->get();
+            $deployments = ApplicationDeploymentQueue::whereIn('status', ['in_progress', 'queued'])->where('server_id', $server->id)->get();
             foreach ($deployments as $deployment) {
                 $deployment->update(['status' => 'failed']);
-                instant_remote_process(['docker rm -f ' . $deployment->deployment_uuid], $server, false);
+                instant_remote_process(['docker rm -f '.$deployment->deployment_uuid], $server, false);
             }
         }
     }

app/Console/Commands/CleanupDatabase.php

@@ -8,6 +8,7 @@ use Illuminate\Support\Facades\DB;
 class CleanupDatabase extends Command
 {
     protected $signature = 'cleanup:database {--yes}';
+
     protected $description = 'Cleanup database';
 
     public function handle()
@@ -17,7 +18,12 @@ class CleanupDatabase extends Command
         } else {
             echo "Running database cleanup in dry-run mode...\n";
         }
-        $keep_days = 60;
+        if (isCloud()) {
+            // Later on we can increase this to 180 days or dynamically set
+            $keep_days = 60;
+        } else {
+            $keep_days = 60;
+        }
         echo "Keep days: $keep_days\n";
         // Cleanup failed jobs table
         $failed_jobs = DB::table('failed_jobs')->where('failed_at', '<', now()->subDays(1));

app/Console/Commands/CleanupQueue.php

@@ -1,23 +0,0 @@
-<?php
-
-namespace App\Console\Commands;
-
-use Illuminate\Console\Command;
-use Illuminate\Support\Facades\Redis;
-
-class CleanupQueue extends Command
-{
-    protected $signature = 'cleanup:queue';
-    protected $description = 'Cleanup Queue';
-
-    public function handle()
-    {
-        echo "Running queue cleanup...\n";
-        $prefix = config('database.redis.options.prefix');
-        $keys = Redis::connection()->keys('*:laravel*');
-        foreach ($keys as $key) {
-            $keyWithoutPrefix = str_replace($prefix, '', $key);
-            Redis::connection()->del($keyWithoutPrefix);
-        }
-    }
-}

app/Console/Commands/CleanupRedis.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Redis;
+
+class CleanupRedis extends Command
+{
+    protected $signature = 'cleanup:redis';
+
+    protected $description = 'Cleanup Redis';
+
+    public function handle()
+    {
+        echo "Cleanup Redis keys.\n";
+        $prefix = config('database.redis.options.prefix');
+
+        $keys = Redis::connection()->keys('*:laravel*');
+        collect($keys)->each(function ($key) use ($prefix) {
+            $keyWithoutPrefix = str_replace($prefix, '', $key);
+            Redis::connection()->del($keyWithoutPrefix);
+        });
+
+        $queueOverlaps = Redis::connection()->keys('*laravel-queue-overlap*');
+        collect($queueOverlaps)->each(function ($key) {
+            Redis::connection()->del($key);
+        });
+
+    }
+}

app/Console/Commands/CleanupStuckedResources.php

@@ -2,8 +2,13 @@
 
 namespace App\Console\Commands;
 
+use App\Jobs\CleanupHelperContainersJob;
 use App\Models\Application;
+use App\Models\ApplicationDeploymentQueue;
+use App\Models\ApplicationPreview;
+use App\Models\ScheduledDatabaseBackup;
 use App\Models\ScheduledTask;
+use App\Models\Server;
 use App\Models\Service;
 use App\Models\ServiceApplication;
 use App\Models\ServiceDatabase;
@@ -20,6 +25,7 @@ use Illuminate\Console\Command;
 class CleanupStuckedResources extends Command
 {
     protected $signature = 'cleanup:stucked-resources';
+
     protected $description = 'Cleanup Stucked Resources';
 
     public function handle()
@@ -28,9 +34,31 @@ class CleanupStuckedResources extends Command
         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();
+            });
+            foreach ($servers as $server) {
+                CleanupHelperContainersJob::dispatch($server);
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stucked resources: {$e->getMessage()}\n";
+        }
+        try {
+            $applicationsDeploymentQueue = ApplicationDeploymentQueue::get();
+            foreach ($applicationsDeploymentQueue as $applicationDeploymentQueue) {
+                if (is_null($applicationDeploymentQueue->application)) {
+                    echo "Deleting stuck application deployment queue: {$applicationDeploymentQueue->id}\n";
+                    $applicationDeploymentQueue->delete();
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck application deployment queue: {$e->getMessage()}\n";
+        }
         try {
             $applications = Application::withTrashed()->whereNotNull('deleted_at')->get();
             foreach ($applications as $application) {
@@ -40,6 +68,17 @@ class CleanupStuckedResources extends Command
         } catch (\Throwable $e) {
             echo "Error in cleaning stuck application: {$e->getMessage()}\n";
         }
+        try {
+            $applicationsPreviews = ApplicationPreview::get();
+            foreach ($applicationsPreviews as $applicationPreview) {
+                if (! data_get($applicationPreview, 'application')) {
+                    echo "Deleting stuck application preview: {$applicationPreview->uuid}\n";
+                    $applicationPreview->delete();
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck application: {$e->getMessage()}\n";
+        }
         try {
             $postgresqls = StandalonePostgresql::withTrashed()->whereNotNull('deleted_at')->get();
             foreach ($postgresqls as $postgresql) {
@@ -142,7 +181,7 @@ class CleanupStuckedResources extends Command
         try {
             $scheduled_tasks = ScheduledTask::all();
             foreach ($scheduled_tasks as $scheduled_task) {
-                if (!$scheduled_task->service && !$scheduled_task->application) {
+                if (! $scheduled_task->service && ! $scheduled_task->application) {
                     echo "Deleting stuck scheduledtask: {$scheduled_task->name}\n";
                     $scheduled_task->delete();
                 }
@@ -151,23 +190,38 @@ class CleanupStuckedResources extends Command
             echo "Error in cleaning stuck scheduledtasks: {$e->getMessage()}\n";
         }
 
+        try {
+            $scheduled_backups = ScheduledDatabaseBackup::all();
+            foreach ($scheduled_backups as $scheduled_backup) {
+                if (! $scheduled_backup->server()) {
+                    echo "Deleting stuck scheduledbackup: {$scheduled_backup->name}\n";
+                    $scheduled_backup->delete();
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck scheduledbackups: {$e->getMessage()}\n";
+        }
+
         // Cleanup any resources that are not attached to any environment or destination or server
         try {
             $applications = Application::all();
             foreach ($applications as $application) {
-                if (!data_get($application, 'environment')) {
-                    echo 'Application without environment: ' . $application->name . '\n';
+                if (! data_get($application, 'environment')) {
+                    echo 'Application without environment: '.$application->name.'\n';
                     $application->forceDelete();
+
                     continue;
                 }
-                if (!$application->destination()) {
-                    echo 'Application without destination: ' . $application->name . '\n';
+                if (! $application->destination()) {
+                    echo 'Application without destination: '.$application->name.'\n';
                     $application->forceDelete();
+
                     continue;
                 }
-                if (!data_get($application, 'destination.server')) {
-                    echo 'Application without server: ' . $application->name . '\n';
+                if (! data_get($application, 'destination.server')) {
+                    echo 'Application without server: '.$application->name.'\n';
                     $application->forceDelete();
+
                     continue;
                 }
             }
@@ -177,19 +231,22 @@ class CleanupStuckedResources extends Command
         try {
             $postgresqls = StandalonePostgresql::all()->where('id', '!=', 0);
             foreach ($postgresqls as $postgresql) {
-                if (!data_get($postgresql, 'environment')) {
-                    echo 'Postgresql without environment: ' . $postgresql->name . '\n';
+                if (! data_get($postgresql, 'environment')) {
+                    echo 'Postgresql without environment: '.$postgresql->name.'\n';
                     $postgresql->forceDelete();
+
                     continue;
                 }
-                if (!$postgresql->destination()) {
-                    echo 'Postgresql without destination: ' . $postgresql->name . '\n';
+                if (! $postgresql->destination()) {
+                    echo 'Postgresql without destination: '.$postgresql->name.'\n';
                     $postgresql->forceDelete();
+
                     continue;
                 }
-                if (!data_get($postgresql, 'destination.server')) {
-                    echo 'Postgresql without server: ' . $postgresql->name . '\n';
+                if (! data_get($postgresql, 'destination.server')) {
+                    echo 'Postgresql without server: '.$postgresql->name.'\n';
                     $postgresql->forceDelete();
+
                     continue;
                 }
             }
@@ -199,19 +256,22 @@ class CleanupStuckedResources extends Command
         try {
             $redis = StandaloneRedis::all();
             foreach ($redis as $redis) {
-                if (!data_get($redis, 'environment')) {
-                    echo 'Redis without environment: ' . $redis->name . '\n';
+                if (! data_get($redis, 'environment')) {
+                    echo 'Redis without environment: '.$redis->name.'\n';
                     $redis->forceDelete();
+
                     continue;
                 }
-                if (!$redis->destination()) {
-                    echo 'Redis without destination: ' . $redis->name . '\n';
+                if (! $redis->destination()) {
+                    echo 'Redis without destination: '.$redis->name.'\n';
                     $redis->forceDelete();
+
                     continue;
                 }
-                if (!data_get($redis, 'destination.server')) {
-                    echo 'Redis without server: ' . $redis->name . '\n';
+                if (! data_get($redis, 'destination.server')) {
+                    echo 'Redis without server: '.$redis->name.'\n';
                     $redis->forceDelete();
+
                     continue;
                 }
             }
@@ -222,19 +282,22 @@ class CleanupStuckedResources extends Command
         try {
             $mongodbs = StandaloneMongodb::all();
             foreach ($mongodbs as $mongodb) {
-                if (!data_get($mongodb, 'environment')) {
-                    echo 'Mongodb without environment: ' . $mongodb->name . '\n';
+                if (! data_get($mongodb, 'environment')) {
+                    echo 'Mongodb without environment: '.$mongodb->name.'\n';
                     $mongodb->forceDelete();
+
                     continue;
                 }
-                if (!$mongodb->destination()) {
-                    echo 'Mongodb without destination: ' . $mongodb->name . '\n';
+                if (! $mongodb->destination()) {
+                    echo 'Mongodb without destination: '.$mongodb->name.'\n';
                     $mongodb->forceDelete();
+
                     continue;
                 }
-                if (!data_get($mongodb, 'destination.server')) {
-                    echo 'Mongodb without server:  ' . $mongodb->name . '\n';
+                if (! data_get($mongodb, 'destination.server')) {
+                    echo 'Mongodb without server:  '.$mongodb->name.'\n';
                     $mongodb->forceDelete();
+
                     continue;
                 }
             }
@@ -245,19 +308,22 @@ class CleanupStuckedResources extends Command
         try {
             $mysqls = StandaloneMysql::all();
             foreach ($mysqls as $mysql) {
-                if (!data_get($mysql, 'environment')) {
-                    echo 'Mysql without environment: ' . $mysql->name . '\n';
+                if (! data_get($mysql, 'environment')) {
+                    echo 'Mysql without environment: '.$mysql->name.'\n';
                     $mysql->forceDelete();
+
                     continue;
                 }
-                if (!$mysql->destination()) {
-                    echo 'Mysql without destination: ' . $mysql->name . '\n';
+                if (! $mysql->destination()) {
+                    echo 'Mysql without destination: '.$mysql->name.'\n';
                     $mysql->forceDelete();
+
                     continue;
                 }
-                if (!data_get($mysql, 'destination.server')) {
-                    echo 'Mysql without server: ' . $mysql->name . '\n';
+                if (! data_get($mysql, 'destination.server')) {
+                    echo 'Mysql without server: '.$mysql->name.'\n';
                     $mysql->forceDelete();
+
                     continue;
                 }
             }
@@ -268,19 +334,22 @@ class CleanupStuckedResources extends Command
         try {
             $mariadbs = StandaloneMariadb::all();
             foreach ($mariadbs as $mariadb) {
-                if (!data_get($mariadb, 'environment')) {
-                    echo 'Mariadb without environment: ' . $mariadb->name . '\n';
+                if (! data_get($mariadb, 'environment')) {
+                    echo 'Mariadb without environment: '.$mariadb->name.'\n';
                     $mariadb->forceDelete();
+
                     continue;
                 }
-                if (!$mariadb->destination()) {
-                    echo 'Mariadb without destination: ' . $mariadb->name . '\n';
+                if (! $mariadb->destination()) {
+                    echo 'Mariadb without destination: '.$mariadb->name.'\n';
                     $mariadb->forceDelete();
+
                     continue;
                 }
-                if (!data_get($mariadb, 'destination.server')) {
-                    echo 'Mariadb without server: ' . $mariadb->name . '\n';
+                if (! data_get($mariadb, 'destination.server')) {
+                    echo 'Mariadb without server: '.$mariadb->name.'\n';
                     $mariadb->forceDelete();
+
                     continue;
                 }
             }
@@ -291,19 +360,22 @@ class CleanupStuckedResources extends Command
         try {
             $services = Service::all();
             foreach ($services as $service) {
-                if (!data_get($service, 'environment')) {
-                    echo 'Service without environment: ' . $service->name . '\n';
+                if (! data_get($service, 'environment')) {
+                    echo 'Service without environment: '.$service->name.'\n';
                     $service->forceDelete();
+
                     continue;
                 }
-                if (!$service->destination()) {
-                    echo 'Service without destination: ' . $service->name . '\n';
+                if (! $service->destination()) {
+                    echo 'Service without destination: '.$service->name.'\n';
                     $service->forceDelete();
+
                     continue;
                 }
-                if (!data_get($service, 'server')) {
-                    echo 'Service without server: ' . $service->name . '\n';
+                if (! data_get($service, 'server')) {
+                    echo 'Service without server: '.$service->name.'\n';
                     $service->forceDelete();
+
                     continue;
                 }
             }
@@ -313,9 +385,10 @@ class CleanupStuckedResources extends Command
         try {
             $serviceApplications = ServiceApplication::all();
             foreach ($serviceApplications as $service) {
-                if (!data_get($service, 'service')) {
-                    echo 'ServiceApplication without service: ' . $service->name . '\n';
+                if (! data_get($service, 'service')) {
+                    echo 'ServiceApplication without service: '.$service->name.'\n';
                     $service->forceDelete();
+
                     continue;
                 }
             }
@@ -325,9 +398,10 @@ class CleanupStuckedResources extends Command
         try {
             $serviceDatabases = ServiceDatabase::all();
             foreach ($serviceDatabases as $service) {
-                if (!data_get($service, 'service')) {
-                    echo 'ServiceDatabase without service: ' . $service->name . '\n';
+                if (! data_get($service, 'service')) {
+                    echo 'ServiceDatabase without service: '.$service->name.'\n';
                     $service->forceDelete();
+
                     continue;
                 }
             }

app/Console/Commands/CleanupUnreachableServers.php

@@ -8,6 +8,7 @@ use Illuminate\Console\Command;
 class CleanupUnreachableServers extends Command
 {
     protected $signature = 'cleanup:unreachable-servers';
+
     protected $description = 'Cleanup Unreachable Servers (7 days)';
 
     public function handle()
@@ -17,9 +18,9 @@ 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...");
+                // send_internal_notification("Server $server->name is unreachable for 7 days. Cleaning up...");
                 $server->update([
-                    'ip' => '1.2.3.4'
+                    'ip' => '1.2.3.4',
                 ]);
             }
         }

app/Console/Commands/CloudCleanupSubscriptions.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Team;
+use Illuminate\Console\Command;
+
+class CloudCleanupSubscriptions extends Command
+{
+    protected $signature = 'cloud:cleanup-subs';
+
+    protected $description = 'Cleanup subcriptions teams';
+
+    public function handle()
+    {
+        try {
+            if (! isCloud()) {
+                $this->error('This command can only be run on cloud');
+
+                return;
+            }
+            ray()->clearAll();
+            $this->info('Cleaning up subcriptions teams');
+            $stripe = new \Stripe\StripeClient(config('subscription.stripe_api_key'));
+
+            $teams = Team::all()->filter(function ($team) {
+                return $team->id !== 0;
+            })->sortBy('id');
+            foreach ($teams as $team) {
+                if ($team) {
+                    $this->info("Checking team {$team->id}");
+                }
+                if (! data_get($team, 'subscription')) {
+                    $this->disableServers($team);
+
+                    continue;
+                }
+                // 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}");
+
+                    $team->subscription->update([
+                        'stripe_invoice_paid' => false,
+                        'stripe_trial_already_ended' => false,
+                        'stripe_subscription_id' => null,
+                    ]);
+                    $this->disableServers($team);
+
+                    continue;
+                } else {
+                    $subscription = $stripe->subscriptions->retrieve(data_get($team, 'subscription.stripe_subscription_id'), []);
+                    $status = data_get($subscription, 'status');
+                    if ($status === 'active' || $status === 'past_due') {
+                        $team->subscription->update([
+                            'stripe_invoice_paid' => true,
+                            'stripe_trial_already_ended' => false,
+                        ]);
+
+                        continue;
+                    }
+                    $this->info('Subscription status: '.$status);
+                    $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}");
+                    } else {
+                        $this->info("Cancelling subscription for team {$team->id} {$team->name}");
+                        $team->subscription->update([
+                            'stripe_invoice_paid' => false,
+                            'stripe_trial_already_ended' => false,
+                            'stripe_subscription_id' => null,
+                        ]);
+                        $this->disableServers($team);
+                    }
+                }
+            }
+
+        } catch (\Exception $e) {
+            $this->error($e->getMessage());
+
+            return;
+        }
+    }
+
+    private function disableServers(Team $team)
+    {
+        foreach ($team->servers as $server) {
+            if ($server->settings->is_usable === true || $server->settings->is_reachable === true || $server->ip !== '1.2.3.4') {
+                $this->info("Disabling server {$server->id} {$server->name}");
+                $server->settings()->update([
+                    'is_usable' => false,
+                    'is_reachable' => false,
+                ]);
+                $server->update([
+                    'ip' => '1.2.3.4',
+                ]);
+            }
+        }
+
+    }
+}

app/Console/Commands/Dev.php

@@ -9,19 +9,55 @@ use Illuminate\Support\Facades\Process;
 
 class Dev extends Command
 {
-    protected $signature = 'dev:init';
-    protected $description = 'Init the app in dev mode';
+    protected $signature = 'dev {--init} {--generate-openapi}';
+
+    protected $description = 'Helper commands for development.';
 
     public function handle()
+    {
+        if ($this->option('init')) {
+            $this->init();
+
+            return;
+        }
+        if ($this->option('generate-openapi')) {
+            $this->generateOpenApi();
+
+            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']);
+        $error = $process->errorOutput();
+        $error = preg_replace('/^.*an object literal,.*$/m', '', $error);
+        $error = preg_replace('/^\h*\v+/m', '', $error);
+        echo $error;
+        echo $process->output();
+    }
+
+    public function init()
     {
         // Generate APP_KEY if not exists
+
         if (empty(env('APP_KEY'))) {
             echo "Generating APP_KEY.\n";
             Artisan::call('key:generate');
         }
+
+        // Generate STORAGE link if not exists
+        if (! file_exists(public_path('storage'))) {
+            echo "Generating STORAGE link.\n";
+            Artisan::call('storage:link');
+        }
+
         // Seed database if it's empty
         $settings = InstanceSettings::find(0);
-        if (!$settings) {
+        if (! $settings) {
             echo "Initializing instance, seeding database.\n";
             Artisan::call('migrate --seed');
         } else {

app/Console/Commands/Emails.php

@@ -2,12 +2,10 @@
 
 namespace App\Console\Commands;
 
-use App\Jobs\DatabaseBackupStatusJob;
 use App\Jobs\SendConfirmationForWaitlistJob;
 use App\Models\Application;
 use App\Models\ApplicationPreview;
 use App\Models\ScheduledDatabaseBackup;
-use App\Models\ScheduledDatabaseBackupExecution;
 use App\Models\Server;
 use App\Models\StandalonePostgresql;
 use App\Models\Team;
@@ -49,7 +47,9 @@ class Emails extends Command
      * Execute the console command.
      */
     private ?MailMessage $mail = null;
+
     private ?string $email = null;
+
     public function handle()
     {
         $type = select(
@@ -73,21 +73,22 @@ class Emails extends Command
         );
         $emailsGathered = ['realusers-before-trial', 'realusers-server-lost-connection'];
         if (isDev()) {
-            $this->email = "test@example.com";
+            $this->email = 'test@example.com';
         } else {
-            if (!in_array($type, $emailsGathered)) {
+            if (! in_array($type, $emailsGathered)) {
                 $this->email = text('Email Address to send to:');
             }
         }
         set_transanctional_email_settings();
 
-        $this->mail = new MailMessage();
-        $this->mail->subject("Test Email");
+        $this->mail = new MailMessage;
+        $this->mail->subject('Test Email');
         switch ($type) {
             case 'updates':
                 $teams = Team::all();
-                if (!$teams || $teams->isEmpty()) {
-                    echo 'No teams found.' . PHP_EOL;
+                if (! $teams || $teams->isEmpty()) {
+                    echo 'No teams found.'.PHP_EOL;
+
                     return;
                 }
                 $emails = [];
@@ -99,25 +100,25 @@ class Emails extends Command
                     }
                 }
                 $emails = array_unique($emails);
-                $this->info("Sending to " . count($emails) . " emails.");
+                $this->info('Sending to '.count($emails).' emails.');
                 foreach ($emails as $email) {
                     $this->info($email);
                 }
                 $confirmed = confirm('Are you sure?');
                 if ($confirmed) {
                     foreach ($emails as $email) {
-                        $this->mail = new MailMessage();
+                        $this->mail = new MailMessage;
                         $this->mail->subject('One-click Services, Docker Compose support');
                         $unsubscribeUrl = route('unsubscribe.marketing.emails', [
                             'token' => encrypt($email),
                         ]);
-                        $this->mail->view('emails.updates', ["unsubscribeUrl" => $unsubscribeUrl]);
+                        $this->mail->view('emails.updates', ['unsubscribeUrl' => $unsubscribeUrl]);
                         $this->sendEmail($email);
                     }
                 }
                 break;
             case 'emails-test':
-                $this->mail = (new Test())->toMail();
+                $this->mail = (new Test)->toMail();
                 $this->sendEmail();
                 break;
             case 'database-backup-statuses-daily':
@@ -157,7 +158,7 @@ class Emails extends Command
             case 'application-deployment-failed':
                 $application = Application::all()->first();
                 $preview = ApplicationPreview::all()->first();
-                if (!$preview) {
+                if (! $preview) {
                     $preview = ApplicationPreview::create([
                         'application_id' => $application->id,
                         'pull_request_id' => 1,
@@ -178,7 +179,7 @@ class Emails extends Command
             case 'backup-failed':
                 $backup = ScheduledDatabaseBackup::all()->first();
                 $db = StandalonePostgresql::all()->first();
-                if (!$backup) {
+                if (! $backup) {
                     $backup = ScheduledDatabaseBackup::create([
                         'enabled' => true,
                         'frequency' => 'daily',
@@ -188,14 +189,14 @@ class Emails extends Command
                         'team_id' => 0,
                     ]);
                 }
-                $output = 'Because of an error, the backup of the database ' . $db->name . ' failed.';
+                $output = 'Because of an error, the backup of the database '.$db->name.' failed.';
                 $this->mail = (new BackupFailed($backup, $db, $output))->toMail();
                 $this->sendEmail();
                 break;
             case 'backup-success':
                 $backup = ScheduledDatabaseBackup::all()->first();
                 $db = StandalonePostgresql::all()->first();
-                if (!$backup) {
+                if (! $backup) {
                     $backup = ScheduledDatabaseBackup::create([
                         'enabled' => true,
                         'frequency' => 'daily',
@@ -223,7 +224,7 @@ class Emails extends Command
                 //     $this->sendEmail();
                 //     break;
             case 'waitlist-invitation-link':
-                $this->mail = new MailMessage();
+                $this->mail = new MailMessage;
                 $this->mail->view('emails.waitlist-invitation', [
                     'loginLink' => 'https://coolify.io',
                 ]);
@@ -240,12 +241,13 @@ class Emails extends Command
 
                 break;
             case 'realusers-before-trial':
-                $this->mail = new MailMessage();
+                $this->mail = new MailMessage;
                 $this->mail->view('emails.before-trial-conversion');
                 $this->mail->subject('Trial period has been added for all subscription plans.');
                 $teams = Team::doesntHave('subscription')->where('id', '!=', 0)->get();
-                if (!$teams || $teams->isEmpty()) {
-                    echo 'No teams found.' . PHP_EOL;
+                if (! $teams || $teams->isEmpty()) {
+                    echo 'No teams found.'.PHP_EOL;
+
                     return;
                 }
                 $emails = [];
@@ -257,7 +259,7 @@ class Emails extends Command
                     }
                 }
                 $emails = array_unique($emails);
-                $this->info("Sending to " . count($emails) . " emails.");
+                $this->info('Sending to '.count($emails).' emails.');
                 foreach ($emails as $email) {
                     $this->info($email);
                 }
@@ -271,7 +273,7 @@ class Emails extends Command
             case 'realusers-server-lost-connection':
                 $serverId = text('Server Id');
                 $server = Server::find($serverId);
-                if (!$server) {
+                if (! $server) {
                     throw new Exception('Server not found');
                 }
                 $admins = [];
@@ -281,22 +283,23 @@ class Emails extends Command
                         $admins[] = $member->email;
                     }
                 }
-                $this->info('Sending to ' . count($admins) . ' admins.');
+                $this->info('Sending to '.count($admins).' admins.');
                 foreach ($admins as $admin) {
                     $this->info($admin);
                 }
-                $this->mail = new MailMessage();
+                $this->mail = new MailMessage;
                 $this->mail->view('emails.server-lost-connection', [
                     'name' => $server->name,
                 ]);
-                $this->mail->subject('Action required: Server ' . $server->name . ' lost connection.');
+                $this->mail->subject('Action required: Server '.$server->name.' lost connection.');
                 foreach ($admins as $email) {
                     $this->sendEmail($email);
                 }
                 break;
         }
     }
-    private function sendEmail(string $email = null)
+
+    private function sendEmail(?string $email = null)
     {
         if ($email) {
             $this->email = $email;
@@ -307,7 +310,7 @@ class Emails extends Command
             fn (Message $message) => $message
                 ->to($this->email)
                 ->subject($this->mail->subject)
-                ->html((string)$this->mail->render())
+                ->html((string) $this->mail->render())
         );
         $this->info("Email sent to $this->email successfully. 📧");
     }

app/Console/Commands/Horizon.php

@@ -7,7 +7,9 @@ use Illuminate\Console\Command;
 class Horizon extends Command
 {
     protected $signature = 'start:horizon';
+
     protected $description = 'Start Horizon';
+
     public function handle()
     {
         if (config('coolify.is_horizon_enabled')) {

app/Console/Commands/Init.php

@@ -2,103 +2,204 @@
 
 namespace App\Console\Commands;
 
+use App\Actions\Server\StopSentinel;
+use App\Enums\ActivityTypes;
 use App\Enums\ApplicationDeploymentStatus;
-use App\Jobs\CleanupHelperContainersJob;
 use App\Models\ApplicationDeploymentQueue;
-use App\Models\InstanceSettings;
+use App\Models\Environment;
 use App\Models\ScheduledDatabaseBackup;
 use App\Models\Server;
 use App\Models\StandalonePostgresql;
 use Illuminate\Console\Command;
+use Illuminate\Support\Facades\File;
 use Illuminate\Support\Facades\Http;
 
 class Init extends Command
 {
-    protected $signature = 'app:init {--full-cleanup} {--cleanup-deployments}';
+    protected $signature = 'app:init {--force-cloud}';
+
     protected $description = 'Cleanup instance related stuffs';
 
+    public $servers = null;
+
     public function handle()
     {
-        $this->alive();
-        get_public_ips();
-        $full_cleanup = $this->option('full-cleanup');
-        $cleanup_deployments = $this->option('cleanup-deployments');
-        if ($cleanup_deployments) {
-            echo "Running cleanup deployments.\n";
-            $this->cleanup_in_progress_application_deployments();
+        if (isCloud() && ! $this->option('force-cloud')) {
+            echo "Skipping init as we are on cloud and --force-cloud option is not set\n";
+
             return;
         }
-        if ($full_cleanup) {
-            // Required for falsely deleted coolify db
-            $this->restore_coolify_db_backup();
-            $this->cleanup_in_progress_application_deployments();
-            $this->cleanup_stucked_helper_containers();
-            $this->call('cleanup:queue');
-            $this->call('cleanup:stucked-resources');
-            if (!isCloud()) {
-                try {
-                    $server = Server::find(0)->first();
-                    $server->setupDynamicProxyConfiguration();
-                } catch (\Throwable $e) {
-                    echo "Could not setup dynamic configuration: {$e->getMessage()}\n";
-                }
-            }
 
-            $settings = InstanceSettings::get();
-            if (!is_null(env('AUTOUPDATE', null))) {
+        $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_traefik_labels();
+        if (! isCloud() || $this->option('force-cloud')) {
+            $this->cleanup_unused_network_from_coolify_proxy();
+        }
+        if (isCloud()) {
+            $this->cleanup_unnecessary_dynamic_proxy_configuration();
+        } else {
+            $this->cleanup_in_progress_application_deployments();
+        }
+        $this->call('cleanup:redis');
+        $this->call('cleanup:stucked-resources');
+
+        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));
+            }
+        } else {
+            try {
+                $localhost = $this->servers->where('id', 0)->first();
+                $localhost->setupDynamicProxyConfiguration();
+            } catch (\Throwable $e) {
+                echo "Could not setup dynamic configuration: {$e->getMessage()}\n";
+            }
+            $settings = instanceSettings();
+            if (! is_null(env('AUTOUPDATE', null))) {
                 if (env('AUTOUPDATE') == true) {
                     $settings->update(['is_auto_update_enabled' => true]);
                 } else {
                     $settings->update(['is_auto_update_enabled' => false]);
                 }
             }
-            return;
         }
-        $this->cleanup_stucked_helper_containers();
-        $this->call('cleanup:stucked-resources');
+    }
+
+    private function disable_metrics()
+    {
+        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);
+                }
+            }
+        }
+    }
+
+    private function update_traefik_labels()
+    {
+        try {
+            Server::where('proxy->type', 'TRAEFIK_V2')->update(['proxy->type' => 'TRAEFIK']);
+        } catch (\Throwable $e) {
+            echo "Error in updating traefik labels: {$e->getMessage()}\n";
+        }
+    }
+
+    private function cleanup_unnecessary_dynamic_proxy_configuration()
+    {
+        foreach ($this->servers as $server) {
+            try {
+                if (! $server->isFunctional()) {
+                    continue;
+                }
+                if ($server->id === 0) {
+                    continue;
+                }
+                $file = $server->proxyPath().'/dynamic/coolify.yaml';
+
+                return instant_remote_process([
+                    "rm -f $file",
+                ], $server, false);
+            } catch (\Throwable $e) {
+                echo "Error in cleaning up unnecessary dynamic proxy configuration: {$e->getMessage()}\n";
+            }
+
+        }
+    }
+
+    private function cleanup_unused_network_from_coolify_proxy()
+    {
+        foreach ($this->servers as $server) {
+            if (! $server->isFunctional()) {
+                continue;
+            }
+            if (! $server->isProxyShouldRun()) {
+                continue;
+            }
+            try {
+                ['networks' => $networks, 'allNetworks' => $allNetworks] = collectDockerNetworksByServer($server);
+                $removeNetworks = $allNetworks->diff($networks);
+                $commands = collect();
+                foreach ($removeNetworks as $network) {
+                    $out = instant_remote_process(["docker network inspect -f json $network | jq '.[].Containers | if . == {} then null else . end'"], $server, false);
+                    if (empty($out)) {
+                        $commands->push("docker network disconnect $network coolify-proxy >/dev/null 2>&1 || true");
+                        $commands->push("docker network rm $network >/dev/null 2>&1 || true");
+                    } else {
+                        $data = collect(json_decode($out, true));
+                        if ($data->count() === 1) {
+                            // If only coolify-proxy itself is connected to that network (it should not be possible, but who knows)
+                            $isCoolifyProxyItself = data_get($data->first(), 'Name') === 'coolify-proxy';
+                            if ($isCoolifyProxyItself) {
+                                $commands->push("docker network disconnect $network coolify-proxy >/dev/null 2>&1 || true");
+                                $commands->push("docker network rm $network >/dev/null 2>&1 || true");
+                            }
+                        }
+                    }
+                }
+                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) {
+                echo "Error in cleaning up unused networks from coolify proxy: {$e->getMessage()}\n";
+            }
+        }
     }
 
     private function restore_coolify_db_backup()
     {
-        try {
-            $database = StandalonePostgresql::withTrashed()->find(0);
-            if ($database && $database->trashed()) {
-                echo "Restoring coolify db backup\n";
-                $database->restore();
-                $scheduledBackup = ScheduledDatabaseBackup::find(0);
-                if (!$scheduledBackup) {
-                    ScheduledDatabaseBackup::create([
-                        'id' => 0,
-                        'enabled' => true,
-                        'save_s3' => false,
-                        'frequency' => '0 0 * * *',
-                        'database_id' => $database->id,
-                        'database_type' => 'App\Models\StandalonePostgresql',
-                        'team_id' => 0,
-                    ]);
+        if (version_compare('4.0.0-beta.179', config('version'), '<=')) {
+            try {
+                $database = StandalonePostgresql::withTrashed()->find(0);
+                if ($database && $database->trashed()) {
+                    echo "Restoring coolify db backup\n";
+                    $database->restore();
+                    $scheduledBackup = ScheduledDatabaseBackup::find(0);
+                    if (! $scheduledBackup) {
+                        ScheduledDatabaseBackup::create([
+                            'id' => 0,
+                            'enabled' => true,
+                            'save_s3' => false,
+                            'frequency' => '0 0 * * *',
+                            'database_id' => $database->id,
+                            'database_type' => 'App\Models\StandalonePostgresql',
+                            'team_id' => 0,
+                        ]);
+                    }
                 }
-            }
-        } catch (\Throwable $e) {
-            echo "Error in restoring coolify db backup: {$e->getMessage()}\n";
-        }
-    }
-    private function cleanup_stucked_helper_containers()
-    {
-        $servers = Server::all();
-        foreach ($servers as $server) {
-            if ($server->isFunctional()) {
-                CleanupHelperContainersJob::dispatch($server);
+            } catch (\Throwable $e) {
+                echo "Error in restoring coolify db backup: {$e->getMessage()}\n";
             }
         }
     }
-    private function alive()
+
+    private function send_alive_signal()
     {
         $id = config('app.id');
         $version = config('version');
-        $settings = InstanceSettings::get();
+        $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";
+
             return;
         }
         try {
@@ -108,27 +209,10 @@ class Init extends Command
             echo "Error in alive: {$e->getMessage()}\n";
         }
     }
-    // private function cleanup_ssh()
-    // {
 
-    // TODO: it will cleanup id.root@host.docker.internal
-    //     try {
-    //         $files = Storage::allFiles('ssh/keys');
-    //         foreach ($files as $file) {
-    //             Storage::delete($file);
-    //         }
-    //         $files = Storage::allFiles('ssh/mux');
-    //         foreach ($files as $file) {
-    //             Storage::delete($file);
-    //         }
-    //     } catch (\Throwable $e) {
-    //         echo "Error in cleaning ssh: {$e->getMessage()}\n";
-    //     }
-    // }
     private function cleanup_in_progress_application_deployments()
     {
         // Cleanup any failed deployments
-
         try {
             if (isCloud()) {
                 return;
@@ -144,4 +228,17 @@ class Init extends Command
             echo "Error: {$e->getMessage()}\n";
         }
     }
+
+    private function replace_slash_in_environment_name()
+    {
+        if (version_compare('4.0.0-beta.298', config('version'), '<=')) {
+            $environments = Environment::all();
+            foreach ($environments as $environment) {
+                if (str_contains($environment->name, '/')) {
+                    $environment->name = str_replace('/', '-', $environment->name);
+                    $environment->save();
+                }
+            }
+        }
+    }
 }

app/Console/Commands/NotifyDemo.php

@@ -3,6 +3,7 @@
 namespace App\Console\Commands;
 
 use Illuminate\Console\Command;
+
 use function Termwind\ask;
 use function Termwind\render;
 use function Termwind\style;
@@ -32,6 +33,7 @@ class NotifyDemo extends Command
 
         if (blank($channel)) {
             $this->showHelp();
+
             return;
         }
 

app/Console/Commands/OpenApi.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Process;
+
+class OpenApi extends Command
+{
+    protected $signature = 'openapi';
+
+    protected $description = 'Generate OpenApi file.';
+
+    public function handle()
+    {
+        // Generate OpenAPI documentation
+        echo "Generating OpenAPI documentation.\n";
+        $process = Process::run(['/var/www/html/vendor/bin/openapi', 'app', '-o', 'openapi.yaml']);
+        $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/RootChangeEmail.php

@@ -35,6 +35,7 @@ class RootChangeEmail extends Command
             $this->info('Root user\'s email updated successfully.');
         } catch (\Exception $e) {
             $this->error('Failed to update root user\'s email.');
+
             return;
         }
     }

app/Console/Commands/RootResetPassword.php

@@ -34,6 +34,7 @@ class RootResetPassword extends Command
         $passwordAgain = password('Again');
         if ($password != $passwordAgain) {
             $this->error('Passwords do not match.');
+
             return;
         }
         $this->info('Updating root password...');
@@ -42,6 +43,7 @@ class RootResetPassword extends Command
             $this->info('Root password updated successfully.');
         } catch (\Exception $e) {
             $this->error('Failed to update root password.');
+
             return;
         }
     }

app/Console/Commands/Scheduler.php

@@ -7,7 +7,9 @@ use Illuminate\Console\Command;
 class Scheduler extends Command
 {
     protected $signature = 'start:scheduler';
+
     protected $description = 'Start Scheduler';
+
     public function handle()
     {
         if (config('coolify.is_scheduler_enabled')) {

app/Console/Commands/ServicesDelete.php

@@ -48,11 +48,13 @@ class ServicesDelete extends Command
             $this->deleteServer();
         }
     }
+
     private function deleteServer()
     {
         $servers = Server::all();
         if ($servers->count() === 0) {
             $this->error('There are no applications to delete.');
+
             return;
         }
         $serversToDelete = multiselect(
@@ -64,19 +66,21 @@ class ServicesDelete extends Command
             $toDelete = $servers->where('id', $server)->first();
             if ($toDelete) {
                 $this->info($toDelete);
-                $confirmed = confirm("Are you sure you want to delete all selected resources?");
-                if (!$confirmed) {
+                $confirmed = confirm('Are you sure you want to delete all selected resources?');
+                if (! $confirmed) {
                     break;
                 }
                 $toDelete->delete();
             }
         }
     }
+
     private function deleteApplication()
     {
         $applications = Application::all();
         if ($applications->count() === 0) {
             $this->error('There are no applications to delete.');
+
             return;
         }
         $applicationsToDelete = multiselect(
@@ -88,19 +92,21 @@ class ServicesDelete extends Command
             $toDelete = $applications->where('id', $application)->first();
             if ($toDelete) {
                 $this->info($toDelete);
-                $confirmed = confirm("Are you sure you want to delete all selected resources? ");
-                if (!$confirmed) {
+                $confirmed = confirm('Are you sure you want to delete all selected resources? ');
+                if (! $confirmed) {
                     break;
                 }
                 DeleteResourceJob::dispatch($toDelete);
             }
         }
     }
+
     private function deleteDatabase()
     {
         $databases = StandalonePostgresql::all();
         if ($databases->count() === 0) {
             $this->error('There are no databases to delete.');
+
             return;
         }
         $databasesToDelete = multiselect(
@@ -112,19 +118,21 @@ class ServicesDelete extends Command
             $toDelete = $databases->where('id', $database)->first();
             if ($toDelete) {
                 $this->info($toDelete);
-                $confirmed = confirm("Are you sure you want to delete all selected resources?");
-                if (!$confirmed) {
+                $confirmed = confirm('Are you sure you want to delete all selected resources?');
+                if (! $confirmed) {
                     return;
                 }
                 DeleteResourceJob::dispatch($toDelete);
             }
         }
     }
+
     private function deleteService()
     {
         $services = Service::all();
         if ($services->count() === 0) {
             $this->error('There are no services to delete.');
+
             return;
         }
         $servicesToDelete = multiselect(
@@ -136,8 +144,8 @@ class ServicesDelete extends Command
             $toDelete = $services->where('id', $service)->first();
             if ($toDelete) {
                 $this->info($toDelete);
-                $confirmed = confirm("Are you sure you want to delete all selected resources?");
-                if (!$confirmed) {
+                $confirmed = confirm('Are you sure you want to delete all selected resources?');
+                if (! $confirmed) {
                     return;
                 }
                 DeleteResourceJob::dispatch($toDelete);

app/Console/Commands/ServicesGenerate.php

@@ -50,12 +50,13 @@ class ServicesGenerate extends Command
         // $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();
+            $ignore = (bool) str($ignore[0])->after('# ignore:')->trim()->value();
         } else {
             $ignore = false;
         }
         if ($ignore) {
             $this->info("Ignoring $file");
+
             return;
         }
         $this->info("Processing $file");
@@ -77,7 +78,7 @@ class ServicesGenerate extends Command
         if ($logo->count() > 0) {
             $logo = str($logo[0])->after('# logo:')->trim()->value();
         } else {
-            $logo = 'svgs/unknown.svg';
+            $logo = 'svgs/coolify.png';
         }
         $minversion = collect(preg_grep('/^# minversion:/', explode("\n", $content)))->values();
         if ($minversion->count() > 0) {
@@ -125,6 +126,7 @@ class ServicesGenerate extends Command
             $env_file_base64 = base64_encode($env_file_content);
             $payload['envs'] = $env_file_base64;
         }
+
         return $payload;
     }
 }

app/Console/Commands/SyncBunny.php

@@ -16,7 +16,7 @@ class SyncBunny extends Command
      *
      * @var string
      */
-    protected $signature = 'sync:bunny {--templates} {--release}';
+    protected $signature = 'sync:bunny {--templates} {--release} {--nightly}';
 
     /**
      * The console command description.
@@ -33,30 +33,38 @@ class SyncBunny extends Command
         $that = $this;
         $only_template = $this->option('templates');
         $only_version = $this->option('release');
-        $bunny_cdn = "https://cdn.coollabs.io";
-        $bunny_cdn_path = "coolify";
-        $bunny_cdn_storage_name = "coolcdn";
+        $nightly = $this->option('nightly');
+        $bunny_cdn = 'https://cdn.coollabs.io';
+        $bunny_cdn_path = 'coolify';
+        $bunny_cdn_storage_name = 'coolcdn';
 
-        $parent_dir = realpath(dirname(__FILE__) . '/../../..');
+        $parent_dir = realpath(dirname(__FILE__).'/../../..');
 
-        $compose_file = "docker-compose.yml";
-        $compose_file_prod = "docker-compose.prod.yml";
-        $install_script = "install.sh";
-        $upgrade_script = "upgrade.sh";
-        $production_env = ".env.production";
-        $service_template = "service-templates.json";
+        $compose_file = 'docker-compose.yml';
+        $compose_file_prod = 'docker-compose.prod.yml';
+        $install_script = 'install.sh';
+        $upgrade_script = 'upgrade.sh';
+        $production_env = '.env.production';
+        $service_template = 'service-templates.json';
+        $versions = 'versions.json';
 
-        $versions = "versions.json";
+        $compose_file_location = "$parent_dir/$compose_file";
+        $compose_file_prod_location = "$parent_dir/$compose_file_prod";
+        $install_script_location = "$parent_dir/scripts/install.sh";
+        $upgrade_script_location = "$parent_dir/scripts/upgrade.sh";
+        $production_env_location = "$parent_dir/.env.production";
+        $versions_location = "$parent_dir/$versions";
 
         PendingRequest::macro('storage', function ($fileName) use ($that) {
             $headers = [
                 'AccessKey' => env('BUNNY_STORAGE_API_KEY'),
                 'Accept' => 'application/json',
-                'Content-Type' => 'application/octet-stream'
+                'Content-Type' => 'application/octet-stream',
             ];
-            $fileStream = fopen($fileName, "r");
+            $fileStream = fopen($fileName, 'r');
             $file = fread($fileStream, filesize($fileName));
-            $that->info('Uploading: ' . $fileName);
+            $that->info('Uploading: '.$fileName);
+
             return PendingRequest::baseUrl('https://storage.bunnycdn.com')->withHeaders($headers)->withBody($file)->throw();
         });
         PendingRequest::macro('purge', function ($url) use ($that) {
@@ -64,20 +72,39 @@ class SyncBunny extends Command
                 'AccessKey' => env('BUNNY_API_KEY'),
                 'Accept' => 'application/json',
             ];
-            $that->info('Purging: ' . $url);
+            $that->info('Purging: '.$url);
+
             return PendingRequest::withHeaders($headers)->get('https://api.bunny.net/purge', [
-                "url" => $url,
-                "async" => false
+                'url' => $url,
+                'async' => false,
             ]);
         });
         try {
-            if (!$only_template && !$only_version) {
-                $this->info('About to sync files (docker-compose.prod.yaml, upgrade.sh, install.sh, etc) to BunnyCDN.');
+            if ($nightly) {
+                $bunny_cdn_path = 'coolify-nightly';
+
+                $compose_file_location = "$parent_dir/other/nightly/$compose_file";
+                $compose_file_prod_location = "$parent_dir/other/nightly/$compose_file_prod";
+                $production_env_location = "$parent_dir/other/nightly/$production_env";
+                $upgrade_script_location = "$parent_dir/other/nightly/$upgrade_script";
+                $install_script_location = "$parent_dir/other/nightly/$install_script";
+                $versions_location = "$parent_dir/other/nightly/$versions";
+            }
+            if (! $only_template && ! $only_version) {
+                if ($nightly) {
+                    $this->info('About to sync files NIGHTLY (docker-compose.prod.yaml, upgrade.sh, install.sh, etc) to BunnyCDN.');
+                } else {
+                    $this->info('About to sync files PRODUCTION (docker-compose.yml, docker-compose.prod.yml, upgrade.sh, install.sh, etc) to BunnyCDN.');
+                }
+                $confirmed = confirm('Are you sure you want to sync?');
+                if (! $confirmed) {
+                    return;
+                }
             }
             if ($only_template) {
                 $this->info('About to sync service-templates.json to BunnyCDN.');
-                $confirmed = confirm("Are you sure you want to sync?");
-                if (!$confirmed) {
+                $confirmed = confirm('Are you sure you want to sync?');
+                if (! $confirmed) {
                     return;
                 }
                 Http::pool(fn (Pool $pool) => [
@@ -85,32 +112,37 @@ class SyncBunny extends Command
                     $pool->purge("$bunny_cdn/$bunny_cdn_path/$service_template"),
                 ]);
                 $this->info('Service template uploaded & purged...');
+
                 return;
-            } else if ($only_version) {
-                $this->info('About to sync versions.json to BunnyCDN.');
-                $file = file_get_contents("$parent_dir/$versions");
+            } elseif ($only_version) {
+                if ($nightly) {
+                    $this->info('About to sync NIGHLTY versions.json to BunnyCDN.');
+                } else {
+                    $this->info('About to sync PRODUCTION versions.json to BunnyCDN.');
+                }
+                $file = file_get_contents($versions_location);
                 $json = json_decode($file, true);
                 $actual_version = data_get($json, 'coolify.v4.version');
 
                 $confirmed = confirm("Are you sure you want to sync to {$actual_version}?");
-                if (!$confirmed) {
+                if (! $confirmed) {
                     return;
                 }
                 Http::pool(fn (Pool $pool) => [
-                    $pool->storage(fileName: "$parent_dir/$versions")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$versions"),
+                    $pool->storage(fileName: $versions_location)->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$versions"),
                     $pool->purge("$bunny_cdn/$bunny_cdn_path/$versions"),
                 ]);
                 $this->info('versions.json uploaded & purged...');
+
                 return;
             }
 
-
             Http::pool(fn (Pool $pool) => [
-                $pool->storage(fileName: "$parent_dir/$compose_file")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$compose_file"),
-                $pool->storage(fileName: "$parent_dir/$compose_file_prod")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$compose_file_prod"),
-                $pool->storage(fileName: "$parent_dir/$production_env")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$production_env"),
-                $pool->storage(fileName: "$parent_dir/scripts/$upgrade_script")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$upgrade_script"),
-                $pool->storage(fileName: "$parent_dir/scripts/$install_script")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$install_script"),
+                $pool->storage(fileName: "$compose_file_location")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$compose_file"),
+                $pool->storage(fileName: "$compose_file_prod_location")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$compose_file_prod"),
+                $pool->storage(fileName: "$production_env_location")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$production_env"),
+                $pool->storage(fileName: "$upgrade_script_location")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$upgrade_script"),
+                $pool->storage(fileName: "$install_script_location")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$install_script"),
             ]);
             Http::pool(fn (Pool $pool) => [
                 $pool->purge("$bunny_cdn/$bunny_cdn_path/$compose_file"),
@@ -119,9 +151,9 @@ class SyncBunny extends Command
                 $pool->purge("$bunny_cdn/$bunny_cdn_path/$upgrade_script"),
                 $pool->purge("$bunny_cdn/$bunny_cdn_path/$install_script"),
             ]);
-            $this->info("All files uploaded & purged...");
+            $this->info('All files uploaded & purged...');
         } catch (\Throwable $e) {
-            $this->error("Error: " . $e->getMessage());
+            $this->error('Error: '.$e->getMessage());
         }
     }
 }

app/Console/Commands/WaitlistInvite.php

@@ -13,7 +13,9 @@ use Illuminate\Support\Str;
 class WaitlistInvite extends Command
 {
     public Waitlist|User|null $next_patient = null;
-    public string|null $password = null;
+
+    public ?string $password = null;
+
     /**
      * The name and signature of the console command.
      *
@@ -38,7 +40,9 @@ class WaitlistInvite extends Command
             $this->main();
         }
     }
-    private function main() {
+
+    private function main()
+    {
         if ($this->argument('email')) {
             if ($this->option('only-email')) {
                 $this->next_patient = User::whereEmail($this->argument('email'))->first();
@@ -50,8 +54,9 @@ class WaitlistInvite extends Command
             } else {
                 $this->next_patient = Waitlist::where('email', $this->argument('email'))->first();
             }
-            if (!$this->next_patient) {
+            if (! $this->next_patient) {
                 $this->error("{$this->argument('email')} not found in the waitlist.");
+
                 return;
             }
         } else {
@@ -60,6 +65,7 @@ class WaitlistInvite extends Command
         if ($this->next_patient) {
             if ($this->option('only-email')) {
                 $this->send_email();
+
                 return;
             }
             $this->register_user();
@@ -69,13 +75,14 @@ class WaitlistInvite extends Command
             $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) {
+        if (! $already_registered) {
             $this->password = Str::password();
             User::create([
-                'name' => Str::of($this->next_patient->email)->before('@'),
+                'name' => str($this->next_patient->email)->before('@'),
                 'email' => $this->next_patient->email,
                 'password' => Hash::make($this->password),
                 'force_password_reset' => true,
@@ -85,21 +92,23 @@ class WaitlistInvite extends Command
             throw new \Exception('User already registered');
         }
     }
+
     private function remove_from_waitlist()
     {
         $this->next_patient->delete();
-        $this->info("User removed from waitlist successfully.");
+        $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 = 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. 📧");
+        $this->info('Email sent successfully. 📧');
     }
 }

app/Console/Kernel.php

@@ -2,16 +2,18 @@
 
 namespace App\Console;
 
-use App\Jobs\CheckLogDrainContainerJob;
+use App\Jobs\CheckForUpdatesJob;
 use App\Jobs\CleanupInstanceStuffsJob;
+use App\Jobs\CleanupStaleMultiplexedConnections;
 use App\Jobs\DatabaseBackupJob;
-use App\Jobs\ScheduledTaskJob;
-use App\Jobs\ContainerStatusJob;
-use App\Jobs\PullCoolifyImageJob;
+use App\Jobs\DockerCleanupJob;
 use App\Jobs\PullHelperImageJob;
 use App\Jobs\PullSentinelImageJob;
 use App\Jobs\PullTemplatesFromCDN;
-use App\Jobs\ServerStatusJob;
+use App\Jobs\ScheduledTaskJob;
+use App\Jobs\ServerCheckJob;
+use App\Jobs\ServerStorageCheckJob;
+use App\Jobs\UpdateCoolifyJob;
 use App\Models\ScheduledDatabaseBackup;
 use App\Models\ScheduledTask;
 use App\Models\Server;
@@ -22,28 +24,34 @@ use Illuminate\Foundation\Console\Kernel as ConsoleKernel;
 class Kernel extends ConsoleKernel
 {
     private $all_servers;
+
     protected function schedule(Schedule $schedule): void
     {
         $this->all_servers = Server::all();
+        $settings = instanceSettings();
+
+        $schedule->job(new CleanupStaleMultiplexedConnections)->hourly();
+
         if (isDev()) {
             // Instance Jobs
             $schedule->command('horizon:snapshot')->everyMinute();
             $schedule->job(new CleanupInstanceStuffsJob)->everyMinute()->onOneServer();
-            $schedule->job(new PullTemplatesFromCDN)->everyTwoHours()->onOneServer();
             // Server Jobs
             $this->check_scheduled_backups($schedule);
             $this->check_resources($schedule);
-            $this->check_scheduled_backups($schedule);
             $this->check_scheduled_tasks($schedule);
             $schedule->command('uploads:clear')->everyTwoMinutes();
+
+            $schedule->command('telescope:prune')->daily();
+
+            $schedule->job(new PullHelperImageJob)->everyFiveMinutes()->onOneServer();
         } else {
             // Instance Jobs
             $schedule->command('horizon:snapshot')->everyFiveMinutes();
-            $schedule->command('cleanup:unreachable-servers')->daily();
-            $schedule->job(new PullCoolifyImageJob)->everyTenMinutes()->onOneServer();
-            $schedule->job(new PullTemplatesFromCDN)->everyThirtyMinutes()->onOneServer();
+            $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();
-            // $schedule->job(new CheckResaleLicenseJob)->hourly()->onOneServer();
+            $this->schedule_updates($schedule);
 
             // Server Jobs
             $this->check_scheduled_backups($schedule);
@@ -55,37 +63,69 @@ class Kernel extends ConsoleKernel
             $schedule->command('uploads:clear')->everyTwoMinutes();
         }
     }
+
     private function pull_images($schedule)
     {
+        $settings = instanceSettings();
         $servers = $this->all_servers->where('settings.is_usable', true)->where('settings.is_reachable', true)->where('ip', '!=', '1.2.3.4');
         foreach ($servers as $server) {
-            if (config('coolify.is_sentinel_enabled')) {
-                $schedule->job(new PullSentinelImageJob($server))->everyFiveMinutes()->onOneServer();
+            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();
             }
-            $schedule->job(new PullHelperImageJob($server))->everyFiveMinutes()->onOneServer();
+        }
+        $schedule->job(new PullHelperImageJob)
+            ->cron($settings->update_check_frequency)
+            ->timezone($settings->instance_timezone)
+            ->onOneServer();
+    }
+
+    private function schedule_updates($schedule)
+    {
+        $settings = instanceSettings();
+
+        $updateCheckFrequency = $settings->update_check_frequency;
+        $schedule->job(new CheckForUpdatesJob)
+            ->cron($updateCheckFrequency)
+            ->timezone($settings->instance_timezone)
+            ->onOneServer();
+
+        if ($settings->is_auto_update_enabled) {
+            $autoUpdateFrequency = $settings->auto_update_frequency;
+            $schedule->job(new UpdateCoolifyJob)
+                ->cron($autoUpdateFrequency)
+                ->timezone($settings->instance_timezone)
+                ->onOneServer();
         }
     }
+
     private function check_resources($schedule)
     {
         if (isCloud()) {
             $servers = $this->all_servers->whereNotNull('team.subscription')->where('team.subscription.stripe_trial_already_ended', false)->where('ip', '!=', '1.2.3.4');
             $own = Team::find(0)->servers;
             $servers = $servers->merge($own);
-            $containerServers = $servers->where('settings.is_swarm_worker', false)->where('settings.is_build_server', false);
         } else {
             $servers = $this->all_servers->where('ip', '!=', '1.2.3.4');
-            $containerServers = $servers->where('settings.is_swarm_worker', false)->where('settings.is_build_server', false);
-        }
-        foreach ($containerServers as $server) {
-            $schedule->job(new ContainerStatusJob($server))->everyMinute()->onOneServer();
-            if ($server->isLogDrainEnabled()) {
-                $schedule->job(new CheckLogDrainContainerJob($server))->everyMinute()->onOneServer();
-            }
         }
         foreach ($servers as $server) {
-            $schedule->job(new ServerStatusJob($server))->everyMinute()->onOneServer();
+            $schedule->job(new ServerCheckJob($server))->everyMinute()->onOneServer();
+            // $schedule->job(new ServerStorageCheckJob($server))->everyMinute()->onOneServer();
+            $serverTimezone = $server->settings->server_timezone;
+            if ($server->settings->force_docker_cleanup) {
+                $schedule->job(new DockerCleanupJob($server))->cron($server->settings->docker_cleanup_frequency)->timezone($serverTimezone)->onOneServer();
+            } else {
+                $schedule->job(new DockerCleanupJob($server))->everyTenMinutes()->timezone($serverTimezone)->onOneServer();
+            }
         }
     }
+
     private function check_scheduled_backups($schedule)
     {
         $scheduled_backups = ScheduledDatabaseBackup::all();
@@ -93,21 +133,29 @@ class Kernel extends ConsoleKernel
             return;
         }
         foreach ($scheduled_backups as $scheduled_backup) {
-            if (!$scheduled_backup->enabled) {
+            if (! $scheduled_backup->enabled) {
                 continue;
             }
             if (is_null(data_get($scheduled_backup, 'database'))) {
                 ray('database not found');
                 $scheduled_backup->delete();
+
                 continue;
             }
 
+            $server = $scheduled_backup->server();
+
+            if (! $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(
                 backup: $scheduled_backup
-            ))->cron($scheduled_backup->frequency)->onOneServer();
+            ))->cron($scheduled_backup->frequency)->timezone($serverTimezone)->onOneServer();
         }
     }
 
@@ -124,9 +172,10 @@ class Kernel extends ConsoleKernel
             $service = $scheduled_task->service;
             $application = $scheduled_task->application;
 
-            if (!$application && !$service) {
+            if (! $application && ! $service) {
                 ray('application/service attached to scheduled task does not exist');
                 $scheduled_task->delete();
+
                 continue;
             }
             if ($application) {
@@ -139,18 +188,25 @@ class Kernel extends ConsoleKernel
                     continue;
                 }
             }
+
+            $server = $scheduled_task->server();
+            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(
                 task: $scheduled_task
-            ))->cron($scheduled_task->frequency)->onOneServer();
+            ))->cron($scheduled_task->frequency)->timezone($serverTimezone)->onOneServer();
         }
     }
 
     protected function commands(): void
     {
-        $this->load(__DIR__ . '/Commands');
+        $this->load(__DIR__.'/Commands');
 
         require base_path('routes/console.php');
     }

app/Data/CoolifyTaskArgs.php

@@ -12,18 +12,18 @@ use Spatie\LaravelData\Data;
 class CoolifyTaskArgs extends Data
 {
     public function __construct(
-        public string  $server_uuid,
-        public string  $command,
-        public string  $type,
+        public string $server_uuid,
+        public string $command,
+        public string $type,
         public ?string $type_uuid = null,
         public ?int $process_id = null,
-        public ?Model  $model = null,
-        public ?string  $status = null ,
-        public bool    $ignore_errors = false,
+        public ?Model $model = null,
+        public ?string $status = null,
+        public bool $ignore_errors = false,
         public $call_event_on_finish = null,
         public $call_event_data = null
     ) {
-        if(is_null($status)){
+        if (is_null($status)) {
             $this->status = ProcessStatus::QUEUED->value;
         }
     }

app/Data/ServerMetadata.php

@@ -9,8 +9,7 @@ use Spatie\LaravelData\Data;
 class ServerMetadata extends Data
 {
     public function __construct(
-        public ?ProxyTypes  $type,
+        public ?ProxyTypes $type,
         public ?ProxyStatus $status
-    ) {
-    }
+    ) {}
 }

app/Enums/ActivityTypes.php

@@ -5,4 +5,5 @@ namespace App\Enums;
 enum ActivityTypes: string
 {
     case INLINE = 'inline';
+    case COMMAND = 'command';
 }

app/Enums/BuildPackTypes.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Enums;
+
+enum BuildPackTypes: string
+{
+    case NIXPACKS = 'nixpacks';
+    case STATIC = 'static';
+    case DOCKERFILE = 'dockerfile';
+    case DOCKERCOMPOSE = 'dockercompose';
+}

app/Enums/ContainerStatusTypes.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Enums;
+
+enum ContainerStatusTypes: string
+{
+    case PAUSED = 'paused';
+    case RESTARTING = 'restarting';
+    case REMOVING = 'removing';
+    case RUNNING = 'running';
+    case DEAD = 'dead';
+    case CREATED = 'created';
+    case EXITED = 'exited';
+}

app/Enums/NewDatabaseTypes.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Enums;
+
+enum NewDatabaseTypes: string
+{
+    case POSTGRESQL = 'postgresql';
+    case MYSQL = 'mysql';
+    case MONGODB = 'mongodb';
+    case REDIS = 'redis';
+    case MARIADB = 'mariadb';
+    case KEYDB = 'keydb';
+    case DRAGONFLY = 'dragonfly';
+    case CLICKHOUSE = 'clickhouse';
+}

app/Enums/NewResourceTypes.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Enums;
+
+enum NewResourceTypes: string
+{
+    case PUBLIC = 'public';
+    case PRIVATE_GH_APP = 'private-gh-app';
+    case PRIVATE_DEPLOY_KEY = 'private-deploy-key';
+    case DOCKERFILE = 'dockerfile';
+    case DOCKERCOMPOSE = 'dockercompose';
+    case DOCKER_IMAGE = 'docker-image';
+    case SERVICE = 'service';
+    case POSTGRESQL = 'postgresql';
+    case MYSQL = 'mysql';
+    case MONGODB = 'mongodb';
+    case REDIS = 'redis';
+    case MARIADB = 'mariadb';
+    case KEYDB = 'keydb';
+    case DRAGONFLY = 'dragonfly';
+    case CLICKHOUSE = 'clickhouse';
+}

app/Enums/ProxyTypes.php

@@ -5,7 +5,7 @@ namespace App\Enums;
 enum ProxyTypes: string
 {
     case NONE = 'NONE';
-    case TRAEFIK_V2 = 'TRAEFIK_V2';
+    case TRAEFIK = 'TRAEFIK';
     case NGINX = 'NGINX';
     case CADDY = 'CADDY';
 }

app/Enums/RedirectTypes.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Enums;
+
+enum RedirectTypes: string
+{
+    case BOTH = 'both';
+    case WWW = 'www';
+    case NON_WWW = 'non-www';
+}

app/Events/ApplicationStatusChanged.php

@@ -2,9 +2,7 @@
 
 namespace App\Events;
 
-use Illuminate\Broadcasting\Channel;
 use Illuminate\Broadcasting\InteractsWithSockets;
-use Illuminate\Broadcasting\PresenceChannel;
 use Illuminate\Broadcasting\PrivateChannel;
 use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
 use Illuminate\Foundation\Events\Dispatchable;
@@ -13,14 +11,16 @@ use Illuminate\Queue\SerializesModels;
 class ApplicationStatusChanged 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");
+            throw new \Exception('Team id is null');
         }
         $this->teamId = $teamId;
     }

app/Events/BackupCreated.php

@@ -2,9 +2,7 @@
 
 namespace App\Events;
 
-use Illuminate\Broadcasting\Channel;
 use Illuminate\Broadcasting\InteractsWithSockets;
-use Illuminate\Broadcasting\PresenceChannel;
 use Illuminate\Broadcasting\PrivateChannel;
 use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
 use Illuminate\Foundation\Events\Dispatchable;
@@ -13,14 +11,16 @@ use Illuminate\Queue\SerializesModels;
 class BackupCreated 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");
+            throw new \Exception('Team id is null');
         }
         $this->teamId = $teamId;
     }

app/Events/CloudflareTunnelConfigured.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 CloudflareTunnelConfigured 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

@@ -2,9 +2,7 @@
 
 namespace App\Events;
 
-use Illuminate\Broadcasting\Channel;
 use Illuminate\Broadcasting\InteractsWithSockets;
-use Illuminate\Broadcasting\PresenceChannel;
 use Illuminate\Broadcasting\PrivateChannel;
 use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
 use Illuminate\Foundation\Events\Dispatchable;
@@ -13,22 +11,28 @@ use Illuminate\Queue\SerializesModels;
 class DatabaseStatusChanged implements ShouldBroadcast
 {
     use Dispatchable, InteractsWithSockets, SerializesModels;
-    public $userId;
+
+    public ?string $userId = null;
+
     public function __construct($userId = null)
     {
         if (is_null($userId)) {
             $userId = auth()->user()->id ?? null;
         }
         if (is_null($userId)) {
-            throw new \Exception("User id is null");
+            return false;
         }
         $this->userId = $userId;
     }
 
-    public function broadcastOn(): array
+    public function broadcastOn(): ?array
     {
-        return [
-            new PrivateChannel("user.{$this->userId}"),
-        ];
+        if ($this->userId) {
+            return [
+                new PrivateChannel("user.{$this->userId}"),
+            ];
+        }
+
+        return null;
     }
 }