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/fix-php-code-style-issues.yml

@@ -1,25 +0,0 @@
-name: Fix PHP code style issues
-
-on: [push]
-
-permissions:
-  contents: write
-
-jobs:
-  php-code-styling:
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.head_ref }}
-
-      - name: Fix PHP code style issues
-        uses: aglipanci/laravel-pint-action@2.4
-
-      - name: Commit changes
-        uses: stefanzweifel/git-auto-commit-action@v5
-        with:
-          commit_message: Fix styling

.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,36 +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 sponsors!
 
-<a href="https://cccareers.org/" target="_blank"><img src="./other/logos/ccc-logo.webp" alt="cccareers logo" width="200"/></a>
-<a href="http://htznr.li/CoolifyXHetzner" target="_blank"><img src="./other/logos/hetzner.jpg" alt="hetzner logo" width="200"/></a>
-<a href="https://logto.io/?ref=coolify" target="_blank"><img src="./other/logos/logto.webp" alt="logto logo" width="200"/></a>
-<a href="https://bc.direct/?utm_source=coolify.io" target="_blank"><img src="./other/logos/bc.png" alt="bc direct logo" width="200"/></a>
-<a href="https://www.quantcdn.io/?utm_source=coolify.io" target="_blank"><img src="./other/logos/quant.svg" alt="quantcdn logo" width="200"/></a>
-<a href="https://arcjet.com/?utm_source=coolify.io" target="_blank"><img src="./other/logos/arcjet.svg" alt="arcjet logo" width="200"/></a>
+### 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.
 
 
 ## Github Sponsors ($40+)
-<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.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>
@@ -61,8 +83,11 @@ Special thanks to our biggest sponsors!
 <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>
@@ -83,9 +108,9 @@ Special thanks to our biggest sponsors!
 
 # 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.
@@ -109,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,6 +2,7 @@
 
 namespace App\Actions\Application;
 
+use App\Actions\Server\CleanupDocker;
 use App\Models\Application;
 use Lorisleiva\Actions\Concerns\AsAction;
 
@@ -9,35 +10,35 @@ class StopApplication
 {
     use AsAction;
 
-    public function handle(Application $application)
+    public function handle(Application $application, bool $previewDeployments = false, bool $dockerCleanup = true)
     {
-        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) {
+        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/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;
 
@@ -40,8 +41,18 @@ class PrepareCoolifyTask
 
     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.');
         }
 
@@ -137,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)

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,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneClickhouse;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -80,14 +79,7 @@ class StartClickhouse
             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 +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";
@@ -155,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/StartDragonfly.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneDragonfly;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -47,9 +46,6 @@ class StartDragonfly
                     'networks' => [
                         $this->database->destination->network,
                     ],
-                    'ulimits' => [
-                        'memlock' => '-1',
-                    ],
                     'labels' => [
                         'coolify.managed' => 'true',
                     ],
@@ -80,14 +76,7 @@ class StartDragonfly
             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";
@@ -155,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,7 +4,6 @@ namespace App\Actions\Database;
 
 use App\Models\StandaloneKeydb;
 use Illuminate\Support\Facades\Storage;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -79,14 +78,7 @@ class StartKeydb
             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;
@@ -111,6 +103,10 @@ class StartKeydb
             ];
             $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";
@@ -163,10 +159,12 @@ 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();
     }
 

app/Actions/Database/StartMariadb.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneMariadb;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -74,14 +73,7 @@ class StartMariadb
             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,6 +97,11 @@ class StartMariadb
                 '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";
@@ -157,21 +154,23 @@ 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();
     }
 

app/Actions/Database/StartMongodb.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneMongodb;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -82,14 +81,7 @@ class StartMongodb
             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;
@@ -122,6 +114,10 @@ class StartMongodb
             '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";
@@ -174,18 +170,20 @@ 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();
     }
 

app/Actions/Database/StartMysql.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneMysql;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -74,14 +73,7 @@ class StartMysql
             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,6 +97,11 @@ class StartMysql
                 '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";
@@ -157,21 +154,23 @@ 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();
     }
 

app/Actions/Database/StartPostgresql.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandalonePostgresql;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -81,14 +80,7 @@ class StartPostgresql
             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;
@@ -127,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";
@@ -179,21 +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();
     }
 

app/Actions/Database/StartRedis.php

@@ -4,7 +4,6 @@ namespace App\Actions\Database;
 
 use App\Models\StandaloneRedis;
 use Illuminate\Support\Facades\Storage;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -83,14 +82,7 @@ class StartRedis
             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;
@@ -115,6 +107,11 @@ class StartRedis
             ];
             $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";
@@ -167,10 +164,12 @@ 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();
     }
 

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()) {
             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,6 +12,7 @@ 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
@@ -20,13 +21,16 @@ class GetContainersStatus
 
     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()) {
             return 'Server is not ready.';
@@ -66,322 +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 = $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());
+    //         // 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);
-        }
-    }
+    //         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];
@@ -407,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');
@@ -461,7 +455,7 @@ 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 {
@@ -486,7 +480,7 @@ 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 {
@@ -549,7 +543,7 @@ class GetContainersStatus
                 }
             }
         }
-        $exitedServices = $exitedServices->unique('id');
+        $exitedServices = $exitedServices->unique('uuid');
         foreach ($exitedServices as $exitedService) {
             if (str($exitedService->status)->startsWith('exited')) {
                 continue;
@@ -657,9 +651,10 @@ class GetContainersStatus
             // $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 {

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;
@@ -20,7 +19,7 @@ class CreateNewUser implements CreatesNewUsers
      */
     public function create(array $input): User
     {
-        $settings = InstanceSettings::get();
+        $settings = instanceSettings();
         if (! $settings->is_registration_enabled) {
             abort(403);
         }
@@ -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 {

app/Actions/License/CheckResaleLicense.php

@@ -2,7 +2,6 @@
 
 namespace App\Actions\License;
 
-use App\Models\InstanceSettings;
 use Illuminate\Support\Facades\Http;
 use Lorisleiva\Actions\Concerns\AsAction;
 
@@ -13,7 +12,7 @@ class CheckResaleLicense
     public function handle()
     {
         try {
-            $settings = InstanceSettings::get();
+            $settings = instanceSettings();
             if (isDev()) {
                 $settings->update([
                     'is_resale_license_active' => true,

app/Actions/Proxy/CheckConfiguration.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Proxy;
 
 use App\Models\Server;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class CheckConfiguration
@@ -22,9 +21,8 @@ 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::of(generate_default_proxy_configuration($server))->trim()->value;
+            $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');

app/Actions/Proxy/CheckProxy.php

@@ -2,14 +2,17 @@
 
 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()) {
             return false;
@@ -26,7 +29,7 @@ class CheckProxy
         if (is_null($proxyType) || $proxyType === 'NONE' || $server->proxy->force_stop) {
             return false;
         }
-        ['uptime' => $uptime, 'error' => $error] = $server->validateConnection();
+        ['uptime' => $uptime, 'error' => $error] = $server->validateConnection(false);
         if (! $uptime) {
             throw new \Exception($error);
         }
@@ -62,22 +65,42 @@ 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;
+                    $portsToCheck = [];
                 }
+            } catch (\Exception $e) {
+                ray($e->getMessage());
             }
-            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;
+            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;
+                    }
                 }
             }
 

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,7 +4,6 @@ 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;
 
@@ -12,11 +11,11 @@ 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([]);
@@ -27,7 +26,7 @@ class StartProxy
             }
             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([
@@ -36,7 +35,7 @@ class StartProxy
                     "echo 'Creating required Docker Compose file.'",
                     "echo 'Starting coolify-proxy.'",
                     'docker stack deploy -c docker-compose.yml coolify-proxy',
-                    "echo 'Proxy started successfully.'",
+                    "echo 'Successfully started coolify-proxy.'",
                 ]);
             } else {
                 $caddfile = 'import /dynamic/*.caddy';
@@ -47,11 +46,14 @@ 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));
             }

app/Actions/Server/CleanupDocker.php

@@ -9,16 +9,31 @@ 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;
@@ -40,12 +41,17 @@ class ConfigureCloudflared
             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',
             ]);
             instant_remote_process($commands, $server);
+
         }
     }
 }

app/Actions/Server/InstallLogDrain.php

@@ -24,12 +24,7 @@ class InstallLogDrain
         }
         try {
             if ($type === 'none') {
-                $command = [
-                    "echo 'Stopping old Fluent Bit'",
-                    'docker rm -f coolify-log-drain || true',
-                ];
-
-                return instant_remote_process($command, $server);
+                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.');
@@ -52,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 *
@@ -103,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           *

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

@@ -12,12 +12,15 @@ class StartSentinel
     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",
+            "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, false);
+        ], $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,7 +2,7 @@
 
 namespace App\Actions\Server;
 
-use App\Models\InstanceSettings;
+use App\Jobs\PullHelperImageJob;
 use App\Models\Server;
 use Lorisleiva\Actions\Concerns\AsAction;
 
@@ -19,13 +19,12 @@ class UpdateCoolify
     public function handle($manual_update = false)
     {
         try {
-            $settings = InstanceSettings::get();
-            ray('Running InstanceAutoUpdateJob');
+            $settings = instanceSettings();
             $this->server = Server::find(0);
             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) {
@@ -40,6 +39,8 @@ class UpdateCoolify
                 }
             }
             $this->update();
+            $settings->new_version_available = false;
+            $settings->save();
         } catch (\Throwable $e) {
             throw $e;
         }
@@ -54,10 +55,18 @@ class UpdateCoolify
 
             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",
         ], $this->server);
-
     }
 }

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,6 +2,7 @@
 
 namespace App\Actions\Service;
 
+use App\Actions\Server\CleanupDocker;
 use App\Models\Service;
 use Lorisleiva\Actions\Concerns\AsAction;
 
@@ -9,11 +10,11 @@ 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();
@@ -33,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();
             }
@@ -50,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

@@ -16,8 +16,10 @@ class StartService
         $service->saveComposeConfigs();
         $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";
+        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';
@@ -29,7 +31,7 @@ class StartService
             $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');

app/Actions/Service/StopService.php

@@ -2,6 +2,7 @@
 
 namespace App\Actions\Service;
 
+use App\Actions\Server\CleanupDocker;
 use App\Models\Service;
 use Lorisleiva\Actions\Concerns\AsAction;
 
@@ -9,34 +10,27 @@ 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()) {
                 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/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,9 +7,9 @@ use Illuminate\Console\Command;
 
 class CleanupApplicationDeploymentQueue extends Command
 {
-    protected $signature = 'cleanup:application-deployment-queue {--team-id=}';
+    protected $signature = 'cleanup:deployment-queue {--team-id=}';
 
-    protected $description = 'CleanupApplicationDeploymentQueue';
+    protected $description = 'Cleanup application deployment queue.';
 
     public function handle()
     {

app/Console/Commands/CleanupDatabase.php

@@ -18,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,24 +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;
@@ -33,6 +38,27 @@ class CleanupStuckedResources extends Command
     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) {
@@ -42,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) {
@@ -153,6 +190,18 @@ 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();

app/Console/Commands/CleanupUnreachableServers.php

@@ -18,7 +18,7 @@ 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',
                 ]);

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,17 +9,52 @@ use Illuminate\Support\Facades\Process;
 
 class Dev extends Command
 {
-    protected $signature = 'dev:init';
+    protected $signature = 'dev {--init} {--generate-openapi}';
 
-    protected $description = 'Init the app in dev mode';
+    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) {

app/Console/Commands/Emails.php

@@ -81,7 +81,7 @@ class Emails extends Command
         }
         set_transanctional_email_settings();
 
-        $this->mail = new MailMessage();
+        $this->mail = new MailMessage;
         $this->mail->subject('Test Email');
         switch ($type) {
             case 'updates':
@@ -107,7 +107,7 @@ class Emails extends Command
                 $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),
@@ -118,7 +118,7 @@ class Emails extends Command
                 }
                 break;
             case 'emails-test':
-                $this->mail = (new Test())->toMail();
+                $this->mail = (new Test)->toMail();
                 $this->sendEmail();
                 break;
             case 'database-backup-statuses-daily':
@@ -224,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',
                 ]);
@@ -241,7 +241,7 @@ 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();
@@ -287,7 +287,7 @@ class Emails extends Command
                 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,
                 ]);

app/Console/Commands/Init.php

@@ -2,51 +2,73 @@
 
 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();
+        $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]);
@@ -54,53 +76,126 @@ class Init extends Command
                     $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";
@@ -114,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;
@@ -150,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/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/ServicesGenerate.php

@@ -78,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) {

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,6 +33,7 @@ class SyncBunny extends Command
         $that = $this;
         $only_template = $this->option('templates');
         $only_version = $this->option('release');
+        $nightly = $this->option('nightly');
         $bunny_cdn = 'https://cdn.coollabs.io';
         $bunny_cdn_path = 'coolify';
         $bunny_cdn_storage_name = 'coolcdn';
@@ -45,9 +46,15 @@ class SyncBunny extends Command
         $upgrade_script = 'upgrade.sh';
         $production_env = '.env.production';
         $service_template = 'service-templates.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'),
@@ -73,8 +80,26 @@ class SyncBunny extends Command
             ]);
         });
         try {
+            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) {
-                $this->info('About to sync files (docker-compose.prod.yaml, upgrade.sh, install.sh, etc) to BunnyCDN.');
+                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.');
@@ -90,8 +115,12 @@ class SyncBunny extends Command
 
                 return;
             } elseif ($only_version) {
-                $this->info('About to sync versions.json to BunnyCDN.');
-                $file = file_get_contents("$parent_dir/$versions");
+                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');
 
@@ -100,7 +129,7 @@ class SyncBunny extends Command
                     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...');
@@ -109,11 +138,11 @@ class SyncBunny extends Command
             }
 
             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"),

app/Console/Commands/WaitlistInvite.php

@@ -82,7 +82,7 @@ class WaitlistInvite extends Command
         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,
@@ -103,7 +103,7 @@ class WaitlistInvite extends Command
     {
         $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,
         ]);

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\ContainerStatusJob;
+use App\Jobs\CleanupStaleMultiplexedConnections;
 use App\Jobs\DatabaseBackupJob;
-use App\Jobs\PullCoolifyImageJob;
+use App\Jobs\DockerCleanupJob;
 use App\Jobs\PullHelperImageJob;
 use App\Jobs\PullSentinelImageJob;
 use App\Jobs\PullTemplatesFromCDN;
 use App\Jobs\ScheduledTaskJob;
-use App\Jobs\ServerStatusJob;
+use App\Jobs\ServerCheckJob;
+use App\Jobs\ServerStorageCheckJob;
+use App\Jobs\UpdateCoolifyJob;
 use App\Models\ScheduledDatabaseBackup;
 use App\Models\ScheduledTask;
 use App\Models\Server;
@@ -26,25 +28,30 @@ class Kernel extends ConsoleKernel
     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);
@@ -59,12 +66,42 @@ class Kernel extends ConsoleKernel
 
     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();
         }
     }
 
@@ -74,19 +111,18 @@ class Kernel extends ConsoleKernel
             $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();
+            }
         }
     }
 
@@ -107,12 +143,19 @@ class Kernel extends ConsoleKernel
                 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();
         }
     }
 
@@ -145,12 +188,19 @@ 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();
         }
     }
 

app/Data/ServerMetadata.php

@@ -11,6 +11,5 @@ class ServerMetadata extends Data
     public function __construct(
         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/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

@@ -12,7 +12,7 @@ class DatabaseStatusChanged implements ShouldBroadcast
 {
     use Dispatchable, InteractsWithSockets, SerializesModels;
 
-    public $userId;
+    public ?string $userId = null;
 
     public function __construct($userId = null)
     {
@@ -20,15 +20,19 @@ class DatabaseStatusChanged implements ShouldBroadcast
             $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;
     }
 }

app/Events/FileStorageChanged.php

@@ -0,0 +1,32 @@
+<?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 FileStorageChanged implements ShouldBroadcast
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public $teamId;
+
+    public function __construct($teamId = null)
+    {
+        ray($teamId);
+        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/ProxyStarted.php

@@ -10,8 +10,5 @@ class ProxyStarted
 {
     use Dispatchable, InteractsWithSockets, SerializesModels;
 
-    public function __construct(public $data)
-    {
-
-    }
+    public function __construct(public $data) {}
 }

app/Events/ServiceStatusChanged.php

@@ -12,7 +12,7 @@ class ServiceStatusChanged implements ShouldBroadcast
 {
     use Dispatchable, InteractsWithSockets, SerializesModels;
 
-    public $userId;
+    public ?string $userId = null;
 
     public function __construct($userId = null)
     {
@@ -20,15 +20,19 @@ class ServiceStatusChanged implements ShouldBroadcast
             $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 (! is_null($this->userId)) {
+            return [
+                new PrivateChannel("user.{$this->userId}"),
+            ];
+        }
+
+        return null;
     }
 }

app/Exceptions/Handler.php

@@ -50,7 +50,7 @@ class Handler extends ExceptionHandler
             return response()->json(['message' => $exception->getMessage()], 401);
         }
 
-        return redirect()->guest($exception->redirectTo() ?? route('login'));
+        return redirect()->guest($exception->redirectTo($request) ?? route('login'));
     }
 
     /**
@@ -65,7 +65,7 @@ class Handler extends ExceptionHandler
             if ($e instanceof RuntimeException) {
                 return;
             }
-            $this->settings = InstanceSettings::get();
+            $this->settings = instanceSettings();
             if ($this->settings->do_not_track) {
                 return;
             }

app/Exceptions/ProcessException.php

@@ -4,6 +4,4 @@ namespace App\Exceptions;
 
 use Exception;
 
-class ProcessException extends Exception
-{
-}
+class ProcessException extends Exception {}

app/Helpers/SshMultiplexingHelper.php

@@ -0,0 +1,186 @@
+<?php
+
+namespace App\Helpers;
+
+use App\Models\PrivateKey;
+use App\Models\Server;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Process;
+
+class SshMultiplexingHelper
+{
+    public static function serverSshConfiguration(Server $server)
+    {
+        $privateKey = PrivateKey::findOrFail($server->private_key_id);
+        $sshKeyLocation = $privateKey->getKeyLocation();
+        $muxFilename = '/var/www/html/storage/app/ssh/mux/mux_'.$server->uuid;
+
+        return [
+            'sshKeyLocation' => $sshKeyLocation,
+            'muxFilename' => $muxFilename,
+        ];
+    }
+
+    public static function ensureMultiplexedConnection(Server $server)
+    {
+        if (! self::isMultiplexingEnabled()) {
+            return;
+        }
+
+        $sshConfig = self::serverSshConfiguration($server);
+        $muxSocket = $sshConfig['muxFilename'];
+        $sshKeyLocation = $sshConfig['sshKeyLocation'];
+
+        self::validateSshKey($sshKeyLocation);
+
+        $checkCommand = "ssh -O check -o ControlPath=$muxSocket ";
+        if (data_get($server, 'settings.is_cloudflare_tunnel')) {
+            $checkCommand .= '-o ProxyCommand="cloudflared access ssh --hostname %h" ';
+        }
+        $checkCommand .= "{$server->user}@{$server->ip}";
+        $process = Process::run($checkCommand);
+
+        if ($process->exitCode() !== 0) {
+            self::establishNewMultiplexedConnection($server);
+        }
+    }
+
+    public static function establishNewMultiplexedConnection(Server $server)
+    {
+        $sshConfig = self::serverSshConfiguration($server);
+        $sshKeyLocation = $sshConfig['sshKeyLocation'];
+        $muxSocket = $sshConfig['muxFilename'];
+
+        $connectionTimeout = config('constants.ssh.connection_timeout');
+        $serverInterval = config('constants.ssh.server_interval');
+        $muxPersistTime = config('constants.ssh.mux_persist_time');
+
+        $establishCommand = "ssh -fNM -o ControlMaster=auto -o ControlPath=$muxSocket -o ControlPersist={$muxPersistTime} ";
+
+        if (data_get($server, 'settings.is_cloudflare_tunnel')) {
+            $establishCommand .= ' -o ProxyCommand="cloudflared access ssh --hostname %h" ';
+        }
+
+        $establishCommand .= self::getCommonSshOptions($server, $sshKeyLocation, $connectionTimeout, $serverInterval);
+        $establishCommand .= "{$server->user}@{$server->ip}";
+
+        $establishProcess = Process::run($establishCommand);
+
+        if ($establishProcess->exitCode() !== 0) {
+            throw new \RuntimeException('Failed to establish multiplexed connection: '.$establishProcess->errorOutput());
+        }
+    }
+
+    public static function removeMuxFile(Server $server)
+    {
+        $sshConfig = self::serverSshConfiguration($server);
+        $muxSocket = $sshConfig['muxFilename'];
+
+        $closeCommand = "ssh -O exit -o ControlPath=$muxSocket ";
+        if (data_get($server, 'settings.is_cloudflare_tunnel')) {
+            $closeCommand .= '-o ProxyCommand="cloudflared access ssh --hostname %h" ';
+        }
+        $closeCommand .= "{$server->user}@{$server->ip}";
+        Process::run($closeCommand);
+    }
+
+    public static function generateScpCommand(Server $server, string $source, string $dest)
+    {
+        $sshConfig = self::serverSshConfiguration($server);
+        $sshKeyLocation = $sshConfig['sshKeyLocation'];
+        $muxSocket = $sshConfig['muxFilename'];
+
+        $timeout = config('constants.ssh.command_timeout');
+        $muxPersistTime = config('constants.ssh.mux_persist_time');
+
+        $scp_command = "timeout $timeout scp ";
+        if ($server->isIpv6()) {
+            $scp_command .= '-6 ';
+        }
+        if (self::isMultiplexingEnabled()) {
+            $scp_command .= "-o ControlMaster=auto -o ControlPath=$muxSocket -o ControlPersist={$muxPersistTime} ";
+            self::ensureMultiplexedConnection($server);
+        }
+
+        if (data_get($server, 'settings.is_cloudflare_tunnel')) {
+            $scp_command .= '-o ProxyCommand="cloudflared access ssh --hostname %h" ';
+        }
+
+        $scp_command .= self::getCommonSshOptions($server, $sshKeyLocation, config('constants.ssh.connection_timeout'), config('constants.ssh.server_interval'), isScp: true);
+        $scp_command .= "{$source} {$server->user}@{$server->ip}:{$dest}";
+
+        return $scp_command;
+    }
+
+    public static function generateSshCommand(Server $server, string $command)
+    {
+        if ($server->settings->force_disabled) {
+            throw new \RuntimeException('Server is disabled.');
+        }
+
+        $sshConfig = self::serverSshConfiguration($server);
+        $sshKeyLocation = $sshConfig['sshKeyLocation'];
+        $muxSocket = $sshConfig['muxFilename'];
+
+        $timeout = config('constants.ssh.command_timeout');
+        $muxPersistTime = config('constants.ssh.mux_persist_time');
+
+        $ssh_command = "timeout $timeout ssh ";
+
+        if (self::isMultiplexingEnabled()) {
+            $ssh_command .= "-o ControlMaster=auto -o ControlPath=$muxSocket -o ControlPersist={$muxPersistTime} ";
+            self::ensureMultiplexedConnection($server);
+        }
+
+        if (data_get($server, 'settings.is_cloudflare_tunnel')) {
+            $ssh_command .= "-o ProxyCommand='cloudflared access ssh --hostname %h' ";
+        }
+
+        $ssh_command .= self::getCommonSshOptions($server, $sshKeyLocation, config('constants.ssh.connection_timeout'), config('constants.ssh.server_interval'));
+
+        $delimiter = Hash::make($command);
+        $delimiter = base64_encode($delimiter);
+        $command = str_replace($delimiter, '', $command);
+
+        $ssh_command .= "{$server->user}@{$server->ip} 'bash -se' << \\$delimiter".PHP_EOL
+            .$command.PHP_EOL
+            .$delimiter;
+
+        return $ssh_command;
+    }
+
+    private static function isMultiplexingEnabled(): bool
+    {
+        return config('constants.ssh.mux_enabled') && ! config('coolify.is_windows_docker_desktop');
+    }
+
+    private static function validateSshKey(string $sshKeyLocation): void
+    {
+        $checkKeyCommand = "ls $sshKeyLocation 2>/dev/null";
+        $keyCheckProcess = Process::run($checkKeyCommand);
+
+        if ($keyCheckProcess->exitCode() !== 0) {
+            throw new \RuntimeException("SSH key file not accessible: $sshKeyLocation");
+        }
+    }
+
+    private static function getCommonSshOptions(Server $server, string $sshKeyLocation, int $connectionTimeout, int $serverInterval, bool $isScp = false): string
+    {
+        $options = "-i {$sshKeyLocation} "
+            .'-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null '
+            .'-o PasswordAuthentication=no '
+            ."-o ConnectTimeout=$connectionTimeout "
+            ."-o ServerAliveInterval=$serverInterval "
+            .'-o RequestTTY=no '
+            .'-o LogLevel=ERROR ';
+
+        // Bruh
+        if ($isScp) {
+            $options .= "-P {$server->port} ";
+        } else {
+            $options .= "-p {$server->port} ";
+        }
+
+        return $options;
+    }
+}

app/Http/Controllers/Api/Deploy.php

@@ -1,216 +0,0 @@
-<?php
-
-namespace App\Http\Controllers\Api;
-
-use App\Actions\Database\StartClickhouse;
-use App\Actions\Database\StartDragonfly;
-use App\Actions\Database\StartKeydb;
-use App\Actions\Database\StartMariadb;
-use App\Actions\Database\StartMongodb;
-use App\Actions\Database\StartMysql;
-use App\Actions\Database\StartPostgresql;
-use App\Actions\Database\StartRedis;
-use App\Actions\Service\StartService;
-use App\Http\Controllers\Controller;
-use App\Models\ApplicationDeploymentQueue;
-use App\Models\Server;
-use App\Models\Tag;
-use Illuminate\Http\Request;
-use Visus\Cuid2\Cuid2;
-
-class Deploy extends Controller
-{
-    public function deployments(Request $request)
-    {
-        $teamId = get_team_id_from_token();
-        if (is_null($teamId)) {
-            return invalid_token();
-        }
-        $servers = Server::whereTeamId($teamId)->get();
-        $deployments_per_server = ApplicationDeploymentQueue::whereIn('status', ['in_progress', 'queued'])->whereIn('server_id', $servers->pluck('id'))->get([
-            'id',
-            'application_id',
-            'application_name',
-            'deployment_url',
-            'pull_request_id',
-            'server_name',
-            'server_id',
-            'status',
-        ])->sortBy('id')->toArray();
-
-        return response()->json($deployments_per_server, 200);
-    }
-
-    public function deploy(Request $request)
-    {
-        $teamId = get_team_id_from_token();
-        $uuids = $request->query->get('uuid');
-        $tags = $request->query->get('tag');
-        $force = $request->query->get('force') ?? false;
-
-        if ($uuids && $tags) {
-            return response()->json(['error' => 'You can only use uuid or tag, not both.', 'docs' => 'https://coolify.io/docs/api-reference/deploy-webhook'], 400);
-        }
-        if (is_null($teamId)) {
-            return invalid_token();
-        }
-        if ($tags) {
-            return $this->by_tags($tags, $teamId, $force);
-        } elseif ($uuids) {
-            return $this->by_uuids($uuids, $teamId, $force);
-        }
-
-        return response()->json(['error' => 'You must provide uuid or tag.', 'docs' => 'https://coolify.io/docs/api-reference/deploy-webhook'], 400);
-    }
-
-    private function by_uuids(string $uuid, int $teamId, bool $force = false)
-    {
-        $uuids = explode(',', $uuid);
-        $uuids = collect(array_filter($uuids));
-
-        if (count($uuids) === 0) {
-            return response()->json(['error' => 'No UUIDs provided.', 'docs' => 'https://coolify.io/docs/api-reference/deploy-webhook'], 400);
-        }
-        $deployments = collect();
-        $payload = collect();
-        foreach ($uuids as $uuid) {
-            $resource = getResourceByUuid($uuid, $teamId);
-            if ($resource) {
-                ['message' => $return_message, 'deployment_uuid' => $deployment_uuid] = $this->deploy_resource($resource, $force);
-                if ($deployment_uuid) {
-                    $deployments->push(['message' => $return_message, 'resource_uuid' => $uuid, 'deployment_uuid' => $deployment_uuid->toString()]);
-                } else {
-                    $deployments->push(['message' => $return_message, 'resource_uuid' => $uuid]);
-                }
-            }
-        }
-        if ($deployments->count() > 0) {
-            $payload->put('deployments', $deployments->toArray());
-
-            return response()->json($payload->toArray(), 200);
-        }
-
-        return response()->json(['error' => 'No resources found.', 'docs' => 'https://coolify.io/docs/api-reference/deploy-webhook'], 404);
-    }
-
-    public function by_tags(string $tags, int $team_id, bool $force = false)
-    {
-        $tags = explode(',', $tags);
-        $tags = collect(array_filter($tags));
-
-        if (count($tags) === 0) {
-            return response()->json(['error' => 'No TAGs provided.', 'docs' => 'https://coolify.io/docs/api-reference/deploy-webhook'], 400);
-        }
-        $message = collect([]);
-        $deployments = collect();
-        $payload = collect();
-        foreach ($tags as $tag) {
-            $found_tag = Tag::where(['name' => $tag, 'team_id' => $team_id])->first();
-            if (! $found_tag) {
-                // $message->push("Tag {$tag} not found.");
-                continue;
-            }
-            $applications = $found_tag->applications()->get();
-            $services = $found_tag->services()->get();
-            if ($applications->count() === 0 && $services->count() === 0) {
-                $message->push("No resources found for tag {$tag}.");
-
-                continue;
-            }
-            foreach ($applications as $resource) {
-                ['message' => $return_message, 'deployment_uuid' => $deployment_uuid] = $this->deploy_resource($resource, $force);
-                if ($deployment_uuid) {
-                    $deployments->push(['resource_uuid' => $resource->uuid, 'deployment_uuid' => $deployment_uuid->toString()]);
-                }
-                $message = $message->merge($return_message);
-            }
-            foreach ($services as $resource) {
-                ['message' => $return_message] = $this->deploy_resource($resource, $force);
-                $message = $message->merge($return_message);
-            }
-        }
-        ray($message);
-        if ($message->count() > 0) {
-            $payload->put('message', $message->toArray());
-            if ($deployments->count() > 0) {
-                $payload->put('details', $deployments->toArray());
-            }
-
-            return response()->json($payload->toArray(), 200);
-        }
-
-        return response()->json(['error' => 'No resources found with this tag.', 'docs' => 'https://coolify.io/docs/api-reference/deploy-webhook'], 404);
-    }
-
-    public function deploy_resource($resource, bool $force = false): array
-    {
-        $message = null;
-        $deployment_uuid = null;
-        if (gettype($resource) !== 'object') {
-            return ['message' => "Resource ($resource) not found.", 'deployment_uuid' => $deployment_uuid];
-        }
-        $type = $resource?->getMorphClass();
-        if ($type === 'App\Models\Application') {
-            $deployment_uuid = new Cuid2(7);
-            queue_application_deployment(
-                application: $resource,
-                deployment_uuid: $deployment_uuid,
-                force_rebuild: $force,
-            );
-            $message = "Application {$resource->name} deployment queued.";
-        } elseif ($type === 'App\Models\StandalonePostgresql') {
-            StartPostgresql::run($resource);
-            $resource->update([
-                'started_at' => now(),
-            ]);
-            $message = "Database {$resource->name} started.";
-        } elseif ($type === 'App\Models\StandaloneRedis') {
-            StartRedis::run($resource);
-            $resource->update([
-                'started_at' => now(),
-            ]);
-            $message = "Database {$resource->name} started.";
-        } elseif ($type === 'App\Models\StandaloneKeydb') {
-            StartKeydb::run($resource);
-            $resource->update([
-                'started_at' => now(),
-            ]);
-            $message = "Database {$resource->name} started.";
-        } elseif ($type === 'App\Models\StandaloneDragonfly') {
-            StartDragonfly::run($resource);
-            $resource->update([
-                'started_at' => now(),
-            ]);
-            $message = "Database {$resource->name} started.";
-        } elseif ($type === 'App\Models\StandaloneClickhouse') {
-            StartClickhouse::run($resource);
-            $resource->update([
-                'started_at' => now(),
-            ]);
-            $message = "Database {$resource->name} started.";
-        } elseif ($type === 'App\Models\StandaloneMongodb') {
-            StartMongodb::run($resource);
-            $resource->update([
-                'started_at' => now(),
-            ]);
-            $message = "Database {$resource->name} started.";
-        } elseif ($type === 'App\Models\StandaloneMysql') {
-            StartMysql::run($resource);
-            $resource->update([
-                'started_at' => now(),
-            ]);
-            $message = "Database {$resource->name} started.";
-        } elseif ($type === 'App\Models\StandaloneMariadb') {
-            StartMariadb::run($resource);
-            $resource->update([
-                'started_at' => now(),
-            ]);
-            $message = "Database {$resource->name} started.";
-        } elseif ($type === 'App\Models\Service') {
-            StartService::run($resource);
-            $message = "Service {$resource->name} started. It could take a while, be patient.";
-        }
-
-        return ['message' => $message, 'deployment_uuid' => $deployment_uuid];
-    }
-}

app/Http/Controllers/Api/DeployController.php

@@ -0,0 +1,320 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Actions\Database\StartDatabase;
+use App\Actions\Service\StartService;
+use App\Http\Controllers\Controller;
+use App\Models\ApplicationDeploymentQueue;
+use App\Models\Server;
+use App\Models\Tag;
+use Illuminate\Http\Request;
+use OpenApi\Attributes as OA;
+use Visus\Cuid2\Cuid2;
+
+class DeployController extends Controller
+{
+    private function removeSensitiveData($deployment)
+    {
+        $token = auth()->user()->currentAccessToken();
+        if ($token->can('view:sensitive')) {
+            return serializeApiResponse($deployment);
+        }
+
+        $deployment->makeHidden([
+            'logs',
+        ]);
+
+        return serializeApiResponse($deployment);
+    }
+
+    #[OA\Get(
+        summary: 'List',
+        description: 'List currently running deployments',
+        path: '/deployments',
+        operationId: 'list-deployments',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Deployments'],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Get all currently running deployments.',
+                content: [
+
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'array',
+                            items: new OA\Items(ref: '#/components/schemas/ApplicationDeploymentQueue'),
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function deployments(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        $servers = Server::whereTeamId($teamId)->get();
+        $deployments_per_server = ApplicationDeploymentQueue::whereIn('status', ['in_progress', 'queued'])->whereIn('server_id', $servers->pluck('id'))->get()->sortBy('id');
+        $deployments_per_server = $deployments_per_server->map(function ($deployment) {
+            return $this->removeSensitiveData($deployment);
+        });
+
+        return response()->json($deployments_per_server);
+    }
+
+    #[OA\Get(
+        summary: 'Get',
+        description: 'Get deployment by UUID.',
+        path: '/deployments/{uuid}',
+        operationId: 'get-deployment-by-uuid',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Deployments'],
+        parameters: [
+            new OA\Parameter(name: 'uuid', in: 'path', required: true, description: 'Deployment UUID', schema: new OA\Schema(type: 'string')),
+        ],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Get deployment by UUID.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            ref: '#/components/schemas/ApplicationDeploymentQueue',
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+            new OA\Response(
+                response: 404,
+                ref: '#/components/responses/404',
+            ),
+        ]
+    )]
+    public function deployment_by_uuid(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        $uuid = $request->route('uuid');
+        if (! $uuid) {
+            return response()->json(['message' => 'UUID is required.'], 400);
+        }
+        $deployment = ApplicationDeploymentQueue::where('deployment_uuid', $uuid)->first();
+        if (! $deployment) {
+            return response()->json(['message' => 'Deployment not found.'], 404);
+        }
+
+        return response()->json($this->removeSensitiveData($deployment));
+    }
+
+    #[OA\Get(
+        summary: 'Deploy',
+        description: 'Deploy by tag or uuid. `Post` request also accepted.',
+        path: '/deploy',
+        operationId: 'deploy-by-tag-or-uuid',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Deployments'],
+        parameters: [
+            new OA\Parameter(name: 'tag', in: 'query', description: 'Tag name(s). Comma separated list is also accepted.', schema: new OA\Schema(type: 'string')),
+            new OA\Parameter(name: 'uuid', in: 'query', description: 'Resource UUID(s). Comma separated list is also accepted.', schema: new OA\Schema(type: 'string')),
+            new OA\Parameter(name: 'force', in: 'query', description: 'Force rebuild (without cache)', schema: new OA\Schema(type: 'boolean')),
+        ],
+
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Get deployment(s) UUID\'s',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'object',
+                            properties: [
+                                'deployments' => new OA\Property(
+                                    property: 'deployments',
+                                    type: 'array',
+                                    items: new OA\Items(
+                                        type: 'object',
+                                        properties: [
+                                            'message' => ['type' => 'string'],
+                                            'resource_uuid' => ['type' => 'string'],
+                                            'deployment_uuid' => ['type' => 'string'],
+                                        ]
+                                    ),
+                                ),
+                            ],
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+
+        ]
+    )]
+    public function deploy(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        $uuids = $request->query->get('uuid');
+        $tags = $request->query->get('tag');
+        $force = $request->query->get('force') ?? false;
+
+        if ($uuids && $tags) {
+            return response()->json(['message' => 'You can only use uuid or tag, not both.'], 400);
+        }
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        if ($tags) {
+            return $this->by_tags($tags, $teamId, $force);
+        } elseif ($uuids) {
+            return $this->by_uuids($uuids, $teamId, $force);
+        }
+
+        return response()->json(['message' => 'You must provide uuid or tag.'], 400);
+    }
+
+    private function by_uuids(string $uuid, int $teamId, bool $force = false)
+    {
+        $uuids = explode(',', $uuid);
+        $uuids = collect(array_filter($uuids));
+
+        if (count($uuids) === 0) {
+            return response()->json(['message' => 'No UUIDs provided.'], 400);
+        }
+        $deployments = collect();
+        $payload = collect();
+        foreach ($uuids as $uuid) {
+            $resource = getResourceByUuid($uuid, $teamId);
+            if ($resource) {
+                ['message' => $return_message, 'deployment_uuid' => $deployment_uuid] = $this->deploy_resource($resource, $force);
+                if ($deployment_uuid) {
+                    $deployments->push(['message' => $return_message, 'resource_uuid' => $uuid, 'deployment_uuid' => $deployment_uuid->toString()]);
+                } else {
+                    $deployments->push(['message' => $return_message, 'resource_uuid' => $uuid]);
+                }
+            }
+        }
+        if ($deployments->count() > 0) {
+            $payload->put('deployments', $deployments->toArray());
+
+            return response()->json(serializeApiResponse($payload->toArray()));
+        }
+
+        return response()->json(['message' => 'No resources found.'], 404);
+    }
+
+    public function by_tags(string $tags, int $team_id, bool $force = false)
+    {
+        $tags = explode(',', $tags);
+        $tags = collect(array_filter($tags));
+
+        if (count($tags) === 0) {
+            return response()->json(['message' => 'No TAGs provided.'], 400);
+        }
+        $message = collect([]);
+        $deployments = collect();
+        $payload = collect();
+        foreach ($tags as $tag) {
+            $found_tag = Tag::where(['name' => $tag, 'team_id' => $team_id])->first();
+            if (! $found_tag) {
+                // $message->push("Tag {$tag} not found.");
+                continue;
+            }
+            $applications = $found_tag->applications()->get();
+            $services = $found_tag->services()->get();
+            if ($applications->count() === 0 && $services->count() === 0) {
+                $message->push("No resources found for tag {$tag}.");
+
+                continue;
+            }
+            foreach ($applications as $resource) {
+                ['message' => $return_message, 'deployment_uuid' => $deployment_uuid] = $this->deploy_resource($resource, $force);
+                if ($deployment_uuid) {
+                    $deployments->push(['resource_uuid' => $resource->uuid, 'deployment_uuid' => $deployment_uuid->toString()]);
+                }
+                $message = $message->merge($return_message);
+            }
+            foreach ($services as $resource) {
+                ['message' => $return_message] = $this->deploy_resource($resource, $force);
+                $message = $message->merge($return_message);
+            }
+        }
+        if ($message->count() > 0) {
+            $payload->put('message', $message->toArray());
+            if ($deployments->count() > 0) {
+                $payload->put('details', $deployments->toArray());
+            }
+
+            return response()->json(serializeApiResponse($payload->toArray()));
+        }
+
+        return response()->json(['message' => 'No resources found with this tag.'], 404);
+    }
+
+    public function deploy_resource($resource, bool $force = false): array
+    {
+        $message = null;
+        $deployment_uuid = null;
+        if (gettype($resource) !== 'object') {
+            return ['message' => "Resource ($resource) not found.", 'deployment_uuid' => $deployment_uuid];
+        }
+        switch ($resource?->getMorphClass()) {
+            case 'App\Models\Application':
+                $deployment_uuid = new Cuid2;
+                queue_application_deployment(
+                    application: $resource,
+                    deployment_uuid: $deployment_uuid,
+                    force_rebuild: $force,
+                );
+                $message = "Application {$resource->name} deployment queued.";
+                break;
+            case 'App\Models\Service':
+                StartService::run($resource);
+                $message = "Service {$resource->name} started. It could take a while, be patient.";
+                break;
+            default:
+                // Database resource
+                StartDatabase::dispatch($resource);
+                $resource->update([
+                    'started_at' => now(),
+                ]);
+                $message = "Database {$resource->name} started.";
+                break;
+        }
+
+        return ['message' => $message, 'deployment_uuid' => $deployment_uuid];
+    }
+}

app/Http/Controllers/Api/Domains.php

@@ -1,104 +0,0 @@
-<?php
-
-namespace App\Http\Controllers\Api;
-
-use App\Http\Controllers\Controller;
-use App\Models\InstanceSettings;
-use App\Models\Project as ModelsProject;
-use Illuminate\Http\Request;
-
-class Domains extends Controller
-{
-    public function domains(Request $request)
-    {
-        $teamId = get_team_id_from_token();
-        if (is_null($teamId)) {
-            return invalid_token();
-        }
-        $projects = ModelsProject::where('team_id', $teamId)->get();
-        $domains = collect();
-        $applications = $projects->pluck('applications')->flatten();
-        $settings = InstanceSettings::get();
-        if ($applications->count() > 0) {
-            foreach ($applications as $application) {
-                $ip = $application->destination->server->ip;
-                $fqdn = str($application->fqdn)->explode(',')->map(function ($fqdn) {
-                    return str($fqdn)->replace('http://', '')->replace('https://', '')->replace('/', '');
-                });
-                if ($ip === 'host.docker.internal') {
-                    if ($settings->public_ipv4) {
-                        $domains->push([
-                            'domain' => $fqdn,
-                            'ip' => $settings->public_ipv4,
-                        ]);
-                    }
-                    if ($settings->public_ipv6) {
-                        $domains->push([
-                            'domain' => $fqdn,
-                            'ip' => $settings->public_ipv6,
-                        ]);
-                    }
-                    if (! $settings->public_ipv4 && ! $settings->public_ipv6) {
-                        $domains->push([
-                            'domain' => $fqdn,
-                            'ip' => $ip,
-                        ]);
-                    }
-                } else {
-                    $domains->push([
-                        'domain' => $fqdn,
-                        'ip' => $ip,
-                    ]);
-                }
-            }
-        }
-        $services = $projects->pluck('services')->flatten();
-        if ($services->count() > 0) {
-            foreach ($services as $service) {
-                $service_applications = $service->applications;
-                if ($service_applications->count() > 0) {
-                    foreach ($service_applications as $application) {
-                        $fqdn = str($application->fqdn)->explode(',')->map(function ($fqdn) {
-                            return str($fqdn)->replace('http://', '')->replace('https://', '')->replace('/', '');
-                        });
-                        if ($ip === 'host.docker.internal') {
-                            if ($settings->public_ipv4) {
-                                $domains->push([
-                                    'domain' => $fqdn,
-                                    'ip' => $settings->public_ipv4,
-                                ]);
-                            }
-                            if ($settings->public_ipv6) {
-                                $domains->push([
-                                    'domain' => $fqdn,
-                                    'ip' => $settings->public_ipv6,
-                                ]);
-                            }
-                            if (! $settings->public_ipv4 && ! $settings->public_ipv6) {
-                                $domains->push([
-                                    'domain' => $fqdn,
-                                    'ip' => $ip,
-                                ]);
-                            }
-                        } else {
-                            $domains->push([
-                                'domain' => $fqdn,
-                                'ip' => $ip,
-                            ]);
-                        }
-                    }
-                }
-            }
-        }
-        $domains = $domains->groupBy('ip')->map(function ($domain) {
-            return $domain->pluck('domain')->flatten();
-        })->map(function ($domain, $ip) {
-            return [
-                'ip' => $ip,
-                'domains' => $domain,
-            ];
-        })->values();
-
-        return response()->json($domains);
-    }
-}

app/Http/Controllers/Api/OpenApi.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use OpenApi\Attributes as OA;
+
+#[OA\Info(title: 'Coolify', version: '0.1')]
+#[OA\Server(url: 'https://app.coolify.io/api/v1', description: 'Coolify Cloud API. Change the host to your own instance if you are self-hosting.')]
+#[OA\SecurityScheme(
+    type: 'http',
+    scheme: 'bearer',
+    securityScheme: 'bearerAuth',
+    description: 'Go to `Keys & Tokens` / `API tokens` and create a new token. Use the token as the bearer token.')]
+#[OA\Components(
+    responses: [
+        new OA\Response(
+            response: 400,
+            description: 'Invalid token.',
+            content: new OA\JsonContent(
+                type: 'object',
+                properties: [
+                    new OA\Property(property: 'message', type: 'string', example: 'Invalid token.'),
+                ]
+            )),
+        new OA\Response(
+            response: 401,
+            description: 'Unauthenticated.',
+            content: new OA\JsonContent(
+                type: 'object',
+                properties: [
+                    new OA\Property(property: 'message', type: 'string', example: 'Unauthenticated.'),
+                ]
+            )),
+        new OA\Response(
+            response: 404,
+            description: 'Resource not found.',
+            content: new OA\JsonContent(
+                type: 'object',
+                properties: [
+                    new OA\Property(property: 'message', type: 'string', example: 'Resource not found.'),
+                ]
+            )),
+    ],
+)]
+class OpenApi
+{
+    // This class is used to generate OpenAPI documentation
+    // for the Coolify API. It is not a controller and does
+    // not contain any routes. It is used to define the
+    // OpenAPI metadata and security scheme for the API.
+}

app/Http/Controllers/Api/OtherController.php

@@ -0,0 +1,187 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Http;
+use OpenApi\Attributes as OA;
+
+class OtherController extends Controller
+{
+    #[OA\Get(
+        summary: 'Version',
+        description: 'Get Coolify version.',
+        path: '/version',
+        operationId: 'version',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Returns the version of the application',
+                content: new OA\JsonContent(
+                    type: 'string',
+                    example: 'v4.0.0',
+                )),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function version(Request $request)
+    {
+        return response(config('version'));
+    }
+
+    #[OA\Get(
+        summary: 'Enable API',
+        description: 'Enable API (only with root permissions).',
+        path: '/enable',
+        operationId: 'enable-api',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Enable API.',
+                content: new OA\JsonContent(
+                    type: 'object',
+                    properties: [
+                        new OA\Property(property: 'message', type: 'string', example: 'API enabled.'),
+                    ]
+                )),
+            new OA\Response(
+                response: 403,
+                description: 'You are not allowed to enable the API.',
+                content: new OA\JsonContent(
+                    type: 'object',
+                    properties: [
+                        new OA\Property(property: 'message', type: 'string', example: 'You are not allowed to enable the API.'),
+                    ]
+                )),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function enable_api(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        if ($teamId !== '0') {
+            return response()->json(['message' => 'You are not allowed to enable the API.'], 403);
+        }
+        $settings = instanceSettings();
+        $settings->update(['is_api_enabled' => true]);
+
+        return response()->json(['message' => 'API enabled.'], 200);
+    }
+
+    #[OA\Get(
+        summary: 'Disable API',
+        description: 'Disable API (only with root permissions).',
+        path: '/disable',
+        operationId: 'disable-api',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Disable API.',
+                content: new OA\JsonContent(
+                    type: 'object',
+                    properties: [
+                        new OA\Property(property: 'message', type: 'string', example: 'API disabled.'),
+                    ]
+                )),
+            new OA\Response(
+                response: 403,
+                description: 'You are not allowed to disable the API.',
+                content: new OA\JsonContent(
+                    type: 'object',
+                    properties: [
+                        new OA\Property(property: 'message', type: 'string', example: 'You are not allowed to disable the API.'),
+                    ]
+                )),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function disable_api(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        if ($teamId !== '0') {
+            return response()->json(['message' => 'You are not allowed to disable the API.'], 403);
+        }
+        $settings = instanceSettings();
+        $settings->update(['is_api_enabled' => false]);
+
+        return response()->json(['message' => 'API disabled.'], 200);
+    }
+
+    public function feedback(Request $request)
+    {
+        $content = $request->input('content');
+        $webhook_url = config('coolify.feedback_discord_webhook');
+        if ($webhook_url) {
+            Http::post($webhook_url, [
+                'content' => $content,
+            ]);
+        }
+
+        return response()->json(['message' => 'Feedback sent.'], 200);
+    }
+
+    #[OA\Get(
+        summary: 'Healthcheck',
+        description: 'Healthcheck endpoint.',
+        path: '/healthcheck',
+        operationId: 'healthcheck',
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Healthcheck endpoint.',
+                content: new OA\JsonContent(
+                    type: 'string',
+                    example: 'OK',
+                )),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function healthcheck(Request $request)
+    {
+        return 'OK';
+    }
+}

app/Http/Controllers/Api/Project.php

@@ -1,44 +0,0 @@
-<?php
-
-namespace App\Http\Controllers\Api;
-
-use App\Http\Controllers\Controller;
-use App\Models\Project as ModelsProject;
-use Illuminate\Http\Request;
-
-class Project extends Controller
-{
-    public function projects(Request $request)
-    {
-        $teamId = get_team_id_from_token();
-        if (is_null($teamId)) {
-            return invalid_token();
-        }
-        $projects = ModelsProject::whereTeamId($teamId)->select('id', 'name', 'uuid')->get();
-
-        return response()->json($projects);
-    }
-
-    public function project_by_uuid(Request $request)
-    {
-        $teamId = get_team_id_from_token();
-        if (is_null($teamId)) {
-            return invalid_token();
-        }
-        $project = ModelsProject::whereTeamId($teamId)->whereUuid(request()->uuid)->first()->load(['environments']);
-
-        return response()->json($project);
-    }
-
-    public function environment_details(Request $request)
-    {
-        $teamId = get_team_id_from_token();
-        if (is_null($teamId)) {
-            return invalid_token();
-        }
-        $project = ModelsProject::whereTeamId($teamId)->whereUuid(request()->uuid)->first();
-        $environment = $project->environments()->whereName(request()->environment_name)->first()->load(['applications', 'postgresqls', 'redis', 'mongodbs', 'mysqls', 'mariadbs', 'services']);
-
-        return response()->json($environment);
-    }
-}

app/Http/Controllers/Api/ProjectController.php

@@ -0,0 +1,434 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Controllers\Controller;
+use App\Models\Project;
+use Illuminate\Http\Request;
+use OpenApi\Attributes as OA;
+
+class ProjectController extends Controller
+{
+    #[OA\Get(
+        summary: 'List',
+        description: 'List projects.',
+        path: '/projects',
+        operationId: 'list-projects',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Projects'],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Get all projects.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'array',
+                            items: new OA\Items(ref: '#/components/schemas/Project')
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function projects(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        $projects = Project::whereTeamId($teamId)->select('id', 'name', 'description', 'uuid')->get();
+
+        return response()->json(serializeApiResponse($projects),
+        );
+    }
+
+    #[OA\Get(
+        summary: 'Get',
+        description: 'Get project by UUID.',
+        path: '/projects/{uuid}',
+        operationId: 'get-project-by-uuid',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Projects'],
+        parameters: [
+            new OA\Parameter(name: 'uuid', in: 'path', required: true, description: 'Project UUID', schema: new OA\Schema(type: 'string')),
+        ],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Project details',
+                content: new OA\JsonContent(ref: '#/components/schemas/Project')),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+            new OA\Response(
+                response: 404,
+                description: 'Project not found.',
+            ),
+        ]
+    )]
+    public function project_by_uuid(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        $project = Project::whereTeamId($teamId)->whereUuid(request()->uuid)->first()->load(['environments']);
+        if (! $project) {
+            return response()->json(['message' => 'Project not found.'], 404);
+        }
+
+        return response()->json(
+            serializeApiResponse($project),
+        );
+    }
+
+    #[OA\Get(
+        summary: 'Environment',
+        description: 'Get environment by name.',
+        path: '/projects/{uuid}/{environment_name}',
+        operationId: 'get-environment-by-name',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Projects'],
+        parameters: [
+            new OA\Parameter(name: 'uuid', in: 'path', required: true, description: 'Project UUID', schema: new OA\Schema(type: 'string')),
+            new OA\Parameter(name: 'environment_name', in: 'path', required: true, description: 'Environment name', schema: new OA\Schema(type: 'string')),
+        ],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Project details',
+                content: new OA\JsonContent(ref: '#/components/schemas/Environment')),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+            new OA\Response(
+                response: 404,
+                ref: '#/components/responses/404',
+            ),
+        ]
+    )]
+    public function environment_details(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        if (! $request->uuid) {
+            return response()->json(['message' => 'UUID is required.'], 422);
+        }
+        if (! $request->environment_name) {
+            return response()->json(['message' => 'Environment name is required.'], 422);
+        }
+        $project = Project::whereTeamId($teamId)->whereUuid($request->uuid)->first();
+        if (! $project) {
+            return response()->json(['message' => 'Project not found.'], 404);
+        }
+        $environment = $project->environments()->whereName($request->environment_name)->first();
+        if (! $environment) {
+            return response()->json(['message' => 'Environment not found.'], 404);
+        }
+        $environment = $environment->load(['applications', 'postgresqls', 'redis', 'mongodbs', 'mysqls', 'mariadbs', 'services']);
+
+        return response()->json(serializeApiResponse($environment));
+    }
+
+    #[OA\Post(
+        summary: 'Create',
+        description: 'Create Project.',
+        path: '/projects',
+        operationId: 'create-project',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Projects'],
+        requestBody: new OA\RequestBody(
+            required: true,
+            description: 'Project created.',
+            content: new OA\MediaType(
+                mediaType: 'application/json',
+                schema: new OA\Schema(
+                    type: 'object',
+                    properties: [
+                        'name' => ['type' => 'string', 'description' => 'The name of the project.'],
+                        'description' => ['type' => 'string', 'description' => 'The description of the project.'],
+                    ],
+                ),
+            ),
+        ),
+        responses: [
+            new OA\Response(
+                response: 201,
+                description: 'Project created.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'object',
+                            properties: [
+                                'uuid' => ['type' => 'string', 'example' => 'og888os', 'description' => 'The UUID of the project.'],
+                            ]
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+            new OA\Response(
+                response: 404,
+                ref: '#/components/responses/404',
+            ),
+        ]
+    )]
+    public function create_project(Request $request)
+    {
+        $allowedFields = ['name', 'description'];
+
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+
+        $return = validateIncomingRequest($request);
+        if ($return instanceof \Illuminate\Http\JsonResponse) {
+            return $return;
+        }
+        $validator = customApiValidator($request->all(), [
+            'name' => 'string|max:255|required',
+            'description' => 'string|nullable',
+        ]);
+
+        $extraFields = array_diff(array_keys($request->all()), $allowedFields);
+        if ($validator->fails() || ! empty($extraFields)) {
+            $errors = $validator->errors();
+            if (! empty($extraFields)) {
+                foreach ($extraFields as $field) {
+                    $errors->add($field, 'This field is not allowed.');
+                }
+            }
+
+            return response()->json([
+                'message' => 'Validation failed.',
+                'errors' => $errors,
+            ], 422);
+        }
+
+        $project = Project::create([
+            'name' => $request->name,
+            'description' => $request->description,
+            'team_id' => $teamId,
+        ]);
+
+        return response()->json([
+            'uuid' => $project->uuid,
+        ])->setStatusCode(201);
+    }
+
+    #[OA\Patch(
+        summary: 'Update',
+        description: 'Update Project.',
+        path: '/projects/{uuid}',
+        operationId: 'update-project-by-uuid',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Projects'],
+        requestBody: new OA\RequestBody(
+            required: true,
+            description: 'Project updated.',
+            content: new OA\MediaType(
+                mediaType: 'application/json',
+                schema: new OA\Schema(
+                    type: 'object',
+                    properties: [
+                        'name' => ['type' => 'string', 'description' => 'The name of the project.'],
+                        'description' => ['type' => 'string', 'description' => 'The description of the project.'],
+                    ],
+                ),
+            ),
+        ),
+        responses: [
+            new OA\Response(
+                response: 201,
+                description: 'Project updated.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'object',
+                            properties: [
+                                'uuid' => ['type' => 'string', 'example' => 'og888os'],
+                                'name' => ['type' => 'string', 'example' => 'Project Name'],
+                                'description' => ['type' => 'string', 'example' => 'Project Description'],
+                            ]
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+            new OA\Response(
+                response: 404,
+                ref: '#/components/responses/404',
+            ),
+        ]
+    )]
+    public function update_project(Request $request)
+    {
+        $allowedFields = ['name', 'description'];
+
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+
+        $return = validateIncomingRequest($request);
+        if ($return instanceof \Illuminate\Http\JsonResponse) {
+            return $return;
+        }
+        $validator = customApiValidator($request->all(), [
+            'name' => 'string|max:255|nullable',
+            'description' => 'string|nullable',
+        ]);
+
+        $extraFields = array_diff(array_keys($request->all()), $allowedFields);
+        if ($validator->fails() || ! empty($extraFields)) {
+            $errors = $validator->errors();
+            if (! empty($extraFields)) {
+                foreach ($extraFields as $field) {
+                    $errors->add($field, 'This field is not allowed.');
+                }
+            }
+
+            return response()->json([
+                'message' => 'Validation failed.',
+                'errors' => $errors,
+            ], 422);
+        }
+        $uuid = $request->uuid;
+        if (! $uuid) {
+            return response()->json(['message' => 'UUID is required.'], 422);
+        }
+
+        $project = Project::whereTeamId($teamId)->whereUuid($uuid)->first();
+        if (! $project) {
+            return response()->json(['message' => 'Project not found.'], 404);
+        }
+
+        $project->update($request->only($allowedFields));
+
+        return response()->json([
+            'uuid' => $project->uuid,
+            'name' => $project->name,
+            'description' => $project->description,
+        ])->setStatusCode(201);
+
+    }
+
+    #[OA\Delete(
+        summary: 'Delete',
+        description: 'Delete project by UUID.',
+        path: '/projects/{uuid}',
+        operationId: 'delete-project-by-uuid',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Projects'],
+        parameters: [
+            new OA\Parameter(
+                name: 'uuid',
+                in: 'path',
+                description: 'UUID of the application.',
+                required: true,
+                schema: new OA\Schema(
+                    type: 'string',
+                    format: 'uuid',
+                )
+            ),
+        ],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Project deleted.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'object',
+                            properties: [
+                                'message' => ['type' => 'string', 'example' => 'Project deleted.'],
+                            ]
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+            new OA\Response(
+                response: 404,
+                ref: '#/components/responses/404',
+            ),
+        ]
+    )]
+    public function delete_project(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+
+        if (! $request->uuid) {
+            return response()->json(['message' => 'UUID is required.'], 422);
+        }
+        $project = Project::whereTeamId($teamId)->whereUuid($request->uuid)->first();
+        if (! $project) {
+            return response()->json(['message' => 'Project not found.'], 404);
+        }
+        if ($project->resource_count() > 0) {
+            return response()->json(['message' => 'Project has resources, so it cannot be deleted.'], 400);
+        }
+
+        $project->delete();
+
+        return response()->json(['message' => 'Project deleted.']);
+    }
+}

app/Http/Controllers/Api/ResourcesController.php

@@ -5,14 +5,43 @@ namespace App\Http\Controllers\Api;
 use App\Http\Controllers\Controller;
 use App\Models\Project;
 use Illuminate\Http\Request;
+use OpenApi\Attributes as OA;
 
-class Resources extends Controller
+class ResourcesController extends Controller
 {
+    #[OA\Get(
+        summary: 'List',
+        description: 'Get all resources.',
+        path: '/resources',
+        operationId: 'list-resources',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Resources'],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Get all resources',
+                content: new OA\JsonContent(
+                    type: 'string',
+                    example: 'Content is very complex. Will be implemented later.',
+                ),
+            ),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
     public function resources(Request $request)
     {
-        $teamId = get_team_id_from_token();
+        $teamId = getTeamIdFromToken();
         if (is_null($teamId)) {
-            return invalid_token();
+            return invalidTokenResponse();
         }
         $projects = Project::where('team_id', $teamId)->get();
         $resources = collect();
@@ -34,6 +63,6 @@ class Resources extends Controller
             return $payload;
         });
 
-        return response()->json($resources);
+        return response()->json(serializeApiResponse($resources));
     }
 }

app/Http/Controllers/Api/SecurityController.php

@@ -0,0 +1,377 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Controllers\Controller;
+use App\Models\PrivateKey;
+use Illuminate\Http\Request;
+use OpenApi\Attributes as OA;
+
+class SecurityController extends Controller
+{
+    private function removeSensitiveData($team)
+    {
+        $token = auth()->user()->currentAccessToken();
+        if ($token->can('view:sensitive')) {
+            return serializeApiResponse($team);
+        }
+        $team->makeHidden([
+            'private_key',
+        ]);
+
+        return serializeApiResponse($team);
+    }
+
+    #[OA\Get(
+        summary: 'List',
+        description: 'List all private keys.',
+        path: '/security/keys',
+        operationId: 'list-private-keys',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Private Keys'],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Get all private keys.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'array',
+                            items: new OA\Items(ref: '#/components/schemas/PrivateKey')
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function keys(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        $keys = PrivateKey::where('team_id', $teamId)->get();
+
+        return response()->json($this->removeSensitiveData($keys));
+    }
+
+    #[OA\Get(
+        summary: 'Get',
+        description: 'Get key by UUID.',
+        path: '/security/keys/{uuid}',
+        operationId: 'get-private-key-by-uuid',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Private Keys'],
+        parameters: [
+            new OA\Parameter(name: 'uuid', in: 'path', required: true, description: 'Private Key UUID', schema: new OA\Schema(type: 'string')),
+        ],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Get all private keys.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'array',
+                            items: new OA\Items(ref: '#/components/schemas/PrivateKey')
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+            new OA\Response(
+                response: 404,
+                description: 'Private Key not found.',
+            ),
+        ]
+    )]
+    public function key_by_uuid(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+
+        $key = PrivateKey::where('team_id', $teamId)->where('uuid', $request->uuid)->first();
+
+        if (is_null($key)) {
+            return response()->json([
+                'message' => 'Private Key not found.',
+            ], 404);
+        }
+
+        return response()->json($this->removeSensitiveData($key));
+    }
+
+    #[OA\Post(
+        summary: 'Create',
+        description: 'Create a new private key.',
+        path: '/security/keys',
+        operationId: 'create-private-key',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Private Keys'],
+        requestBody: new OA\RequestBody(
+            required: true,
+            content: [
+                'application/json' => new OA\MediaType(
+                    mediaType: 'application/json',
+                    schema: new OA\Schema(
+                        type: 'object',
+                        required: ['private_key'],
+                        properties: [
+                            'name' => ['type' => 'string'],
+                            'description' => ['type' => 'string'],
+                            'private_key' => ['type' => 'string'],
+                        ],
+                        additionalProperties: false,
+                    )
+                ),
+            ]
+        ),
+        responses: [
+            new OA\Response(
+                response: 201,
+                description: 'The created private key\'s UUID.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'object',
+                            properties: [
+                                'uuid' => ['type' => 'string'],
+                            ]
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function create_key(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        $return = validateIncomingRequest($request);
+        if ($return instanceof \Illuminate\Http\JsonResponse) {
+            return $return;
+        }
+        $validator = customApiValidator($request->all(), [
+            'name' => 'string|max:255',
+            'description' => 'string|max:255',
+            'private_key' => 'required|string',
+        ]);
+
+        if ($validator->fails()) {
+            $errors = $validator->errors();
+
+            return response()->json([
+                'message' => 'Validation failed.',
+                'errors' => $errors,
+            ], 422);
+        }
+        if (! $request->name) {
+            $request->offsetSet('name', generate_random_name());
+        }
+        if (! $request->description) {
+            $request->offsetSet('description', 'Created by Coolify via API');
+        }
+        $key = PrivateKey::create([
+            'team_id' => $teamId,
+            'name' => $request->name,
+            'description' => $request->description,
+            'private_key' => $request->private_key,
+        ]);
+
+        return response()->json(serializeApiResponse([
+            'uuid' => $key->uuid,
+        ]))->setStatusCode(201);
+    }
+
+    #[OA\Patch(
+        summary: 'Update',
+        description: 'Update a private key.',
+        path: '/security/keys',
+        operationId: 'update-private-key',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Private Keys'],
+        requestBody: new OA\RequestBody(
+            required: true,
+            content: [
+                'application/json' => new OA\MediaType(
+                    mediaType: 'application/json',
+                    schema: new OA\Schema(
+                        type: 'object',
+                        required: ['private_key'],
+                        properties: [
+                            'name' => ['type' => 'string'],
+                            'description' => ['type' => 'string'],
+                            'private_key' => ['type' => 'string'],
+                        ],
+                        additionalProperties: false,
+                    )
+                ),
+            ]
+        ),
+        responses: [
+            new OA\Response(
+                response: 201,
+                description: 'The updated private key\'s UUID.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'object',
+                            properties: [
+                                'uuid' => ['type' => 'string'],
+                            ]
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function update_key(Request $request)
+    {
+        $allowedFields = ['name', 'description', 'private_key'];
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        $return = validateIncomingRequest($request);
+        if ($return instanceof \Illuminate\Http\JsonResponse) {
+            return $return;
+        }
+
+        $validator = customApiValidator($request->all(), [
+            'name' => 'string|max:255',
+            'description' => 'string|max:255',
+            'private_key' => 'required|string',
+        ]);
+
+        $extraFields = array_diff(array_keys($request->all()), $allowedFields);
+        if ($validator->fails() || ! empty($extraFields)) {
+            $errors = $validator->errors();
+            if (! empty($extraFields)) {
+                foreach ($extraFields as $field) {
+                    $errors->add($field, 'This field is not allowed.');
+                }
+            }
+
+            return response()->json([
+                'message' => 'Validation failed.',
+                'errors' => $errors,
+            ], 422);
+        }
+        $foundKey = PrivateKey::where('team_id', $teamId)->where('uuid', $request->uuid)->first();
+        if (is_null($foundKey)) {
+            return response()->json([
+                'message' => 'Private Key not found.',
+            ], 404);
+        }
+        $foundKey->update($request->all());
+
+        return response()->json(serializeApiResponse([
+            'uuid' => $foundKey->uuid,
+        ]))->setStatusCode(201);
+    }
+
+    #[OA\Delete(
+        summary: 'Delete',
+        description: 'Delete a private key.',
+        path: '/security/keys/{uuid}',
+        operationId: 'delete-private-key-by-uuid',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Private Keys'],
+        parameters: [
+            new OA\Parameter(name: 'uuid', in: 'path', required: true, description: 'Private Key UUID', schema: new OA\Schema(type: 'string')),
+        ],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Private Key deleted.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'object',
+                            properties: [
+                                'message' => ['type' => 'string', 'example' => 'Private Key deleted.'],
+                            ]
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+            new OA\Response(
+                response: 404,
+                description: 'Private Key not found.',
+            ),
+        ]
+    )]
+    public function delete_key(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        if (! $request->uuid) {
+            return response()->json(['message' => 'UUID is required.'], 422);
+        }
+
+        $key = PrivateKey::where('team_id', $teamId)->where('uuid', $request->uuid)->first();
+        if (is_null($key)) {
+            return response()->json(['message' => 'Private Key not found.'], 404);
+        }
+        $key->forceDelete();
+
+        return response()->json([
+            'message' => 'Private Key deleted.',
+        ]);
+    }
+}