fix: use correct env variable for invoice ninja password

remove mautic 4 because if it out of support

.coolify-logo

@@ -0,0 +1,8 @@
+   _____            _ _  __
+  / ____|          | (_)/ _|
+ | |     ___   ___ | |_| |_ _   _
+ | |    / _ \ / _ \| | |  _| | | |
+ | |___| (_) | (_) | | | | | |_| |
+  \_____\___/ \___/|_|_|_|  \__, |
+                             __/ |
+                            |___/

.dockerignore

@@ -1,11 +1,25 @@
-.DS_Store
-node_modules
-/build
-/.svelte-kit
-/package
-
+/.phpunit.cache
+/node_modules
+/public/build
+/public/hot
+/public/storage
+/storage/*.key
+/vendor
 .env
-.env.stag
-/db/*.db
-/db/*.db-journal
-/data/haproxy/haproxy.cfg
+.env.backup
+.env.secrets
+.phpunit.result.cache
+Homestead.json
+Homestead.yaml
+auth.json
+npm-debug.log
+yarn-error.log
+/.fleet
+/.idea
+/.vscode
+/.npm
+/.bash_history
+/_data
+.rnd
+/.ssh
+.ignition.json

.editorconfig

@@ -0,0 +1,18 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.{yml,yaml}]
+indent_size = 2
+
+[docker-compose.yml]
+indent_size = 4

.env.development.example

@@ -0,0 +1,34 @@
+# Coolify Configuration
+APP_ENV=local
+APP_NAME="Coolify Development"
+APP_ID=development
+APP_KEY=
+APP_URL=http://localhost
+APP_PORT=8000
+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
+
+# Special Keys for Andras
+# For cache purging
+BUNNY_API_KEY=
+# For asset uploads
+BUNNY_STORAGE_API_KEY=

.env.production

@@ -0,0 +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=

.env.template

@@ -1,5 +0,0 @@
-COOLIFY_APP_ID=
-COOLIFY_SECRET_KEY=
-COOLIFY_DATABASE_URL=file:../db/prod.db
-COOLIFY_SENTRY_DSN=
-COOLIFY_IS_ON="docker"

.env.windows-docker-desktop.example

@@ -0,0 +1,12 @@
+IS_WINDOWS_DOCKER_DESKTOP=true
+
+APP_ID=coolify-windows-docker-desktop
+APP_NAME=Coolify
+APP_KEY=base64:ssTlCmrIE/q7whnKMvT6DwURikg69COzGsAwFVROm80=
+
+DB_PASSWORD=coolify
+REDIS_PASSWORD=coolify
+
+PUSHER_APP_ID=coolify
+PUSHER_APP_KEY=coolify
+PUSHER_APP_SECRET=coolify

.eslintrc.cjs

@@ -1,20 +0,0 @@
-module.exports = {
-	root: true,
-	parser: '@typescript-eslint/parser',
-	extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended', 'prettier'],
-	plugins: ['svelte3', '@typescript-eslint'],
-	ignorePatterns: ['*.cjs'],
-	overrides: [{ files: ['*.svelte'], processor: 'svelte3/svelte3' }],
-	settings: {
-		'svelte3/typescript': () => require('typescript')
-	},
-	parserOptions: {
-		sourceType: 'module',
-		ecmaVersion: 2020
-	},
-	env: {
-		browser: true,
-		es2017: true,
-		node: true
-	}
-};

.gitattributes

@@ -0,0 +1,11 @@
+* text=auto eol=lf
+
+*.blade.php diff=html
+*.css diff=css
+*.html diff=html
+*.md diff=markdown
+*.php diff=php
+
+/.github export-ignore
+CHANGELOG.md export-ignore
+.styleci.yml export-ignore

.github/FUNDING.yaml

@@ -1 +1,2 @@
 open_collective: coollabsio
+github: coollabsio

.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/config.yml

@@ -0,0 +1,18 @@
+blank_issues_enabled: false
+
+contact_links:
+  - name: 🤔 Questions and Community Support
+    url: https://coollabs.io/discord
+    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

@@ -0,0 +1,13 @@
+## 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

@@ -0,0 +1,101 @@
+name: Coolify Helper Image Development (v4)
+
+on:
+  push:
+    branches: [ "next" ]
+    paths:
+      - .github/workflows/coolify-helper-next.yml
+      - docker/coolify-helper/Dockerfile
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: "coollabsio/coolify-helper"
+
+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.helper.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-helper/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.helper.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-helper/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.helper.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 --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

@@ -0,0 +1,101 @@
+name: Coolify Helper Image (v4)
+
+on:
+  push:
+    branches: [ "main" ]
+    paths:
+      - .github/workflows/coolify-helper.yml
+      - docker/coolify-helper/Dockerfile
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: "coollabsio/coolify-helper"
+
+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.helper.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-helper/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.helper.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-helper/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.helper.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/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/coolify-testing-host.yml

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

.github/workflows/development-build.yml

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

.github/workflows/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

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

.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);
+                  }
+                }
+              }
+            }

.gitignore

@@ -1,14 +1,35 @@
-.DS_Store
-node_modules
-/build
-/.svelte-kit
-/package
-/yarn.lock
-
+/.phpunit.cache
+/node_modules
+/public/build
+/public/hot
+/public/storage
+/storage/*.key
+/vendor
 .env
-.env.prod
-.env.stag
-/db/*.db
-/db/*.db-journal
-/data/haproxy/haproxy.cfg
-/data/haproxy/haproxy.cfg.lkg
+.env.backup
+.env.secrets
+.phpunit.result.cache
+Homestead.json
+Homestead.yaml
+auth.json
+npm-debug.log
+yarn-error.log
+/.fleet
+/.idea
+/.vscode
+/.npm
+/.bash_history
+/_data
+_testing_hosts/
+_volumes/
+.lesshst
+psysh_history
+.psql_history
+_ide_helper.php
+.gitignore
+.phpstorm.meta.php
+_ide_helper_models.php
+.rnd
+/.ssh
+scripts/load-test/*
+.ignition.json

.gitpod.yml

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

.husky/_/.gitignore

@@ -1 +0,0 @@
-*

.husky/pre-commit

@@ -1,4 +0,0 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
-yarn lint-staged

.lintstagedrc.json

@@ -1,5 +0,0 @@
-{
-	"**/*.{js,jsx,ts,tsx,cjs,svelte,json,css,scss,md,yaml}": [
-		"prettier --ignore-path .gitignore --write --plugin-search-dir=."
-	]
-}

.prettierrc

@@ -1,6 +0,0 @@
-{
-	"useTabs": true,
-	"singleQuote": true,
-	"trailingComma": "none",
-	"printWidth": 100
-}

CODE_OF_CONDUCT.md

@@ -0,0 +1,94 @@
+# Citizen Code of Conduct
+
+## 1. Purpose
+
+A primary goal of Coolify is to be inclusive to the largest number of contributors, with the most varied and diverse backgrounds possible. As such, we are committed to providing a friendly, safe and welcoming environment for all, regardless of gender, sexual orientation, ability, ethnicity, socioeconomic status, and religion (or lack thereof).
+
+This code of conduct outlines our expectations for all those who participate in our community, as well as the consequences for unacceptable behavior.
+
+We invite all those who participate in Coolify to help us create safe and positive experiences for everyone.
+
+## 2. Open [Source/Culture/Tech] Citizenship
+
+A supplemental goal of this Code of Conduct is to increase open [source/culture/tech] citizenship by encouraging participants to recognize and strengthen the relationships between our actions and their effects on our community.
+
+Communities mirror the societies in which they exist and positive action is essential to counteract the many forms of inequality and abuses of power that exist in society.
+
+If you see someone who is making an extra effort to ensure our community is welcoming, friendly, and encourages all participants to contribute to the fullest extent, we want to know.
+
+## 3. Expected Behavior
+
+The following behaviors are expected and requested of all community members:
+
+ * Participate in an authentic and active way. In doing so, you contribute to the health and longevity of this community.
+ * Exercise consideration and respect in your speech and actions.
+ * Attempt collaboration before conflict.
+ * Refrain from demeaning, discriminatory, or harassing behavior and speech.
+ * Be mindful of your surroundings and of your fellow participants. Alert community leaders if you notice a dangerous situation, someone in distress, or violations of this Code of Conduct, even if they seem inconsequential.
+ * Remember that community event venues may be shared with members of the public; please be respectful to all patrons of these locations.
+
+## 4. Unacceptable Behavior
+
+The following behaviors are considered harassment and are unacceptable within our community:
+
+ * Violence, threats of violence or violent language directed against another person.
+ * Sexist, racist, homophobic, transphobic, ableist or otherwise discriminatory jokes and language.
+ * Posting or displaying sexually explicit or violent material.
+ * Posting or threatening to post other people's personally identifying information ("doxing").
+ * Personal insults, particularly those related to gender, sexual orientation, race, religion, or disability.
+ * Inappropriate photography or recording.
+ * Inappropriate physical contact. You should have someone's consent before touching them.
+ * Unwelcome sexual attention. This includes, sexualized comments or jokes; inappropriate touching, groping, and unwelcomed sexual advances.
+ * Deliberate intimidation, stalking or following (online or in person).
+ * Advocating for, or encouraging, any of the above behavior.
+ * Sustained disruption of community events, including talks and presentations.
+
+## 5. Weapons Policy
+
+No weapons will be allowed at Coolify events, community spaces, or in other spaces covered by the scope of this Code of Conduct. Weapons include but are not limited to guns, explosives (including fireworks), and large knives such as those used for hunting or display, as well as any other item used for the purpose of causing injury or harm to others. Anyone seen in possession of one of these items will be asked to leave immediately, and will only be allowed to return without the weapon. Community members are further expected to comply with all state and local laws on this matter.
+
+## 6. Consequences of Unacceptable Behavior
+
+Unacceptable behavior from any community member, including sponsors and those with decision-making authority, will not be tolerated.
+
+Anyone asked to stop unacceptable behavior is expected to comply immediately.
+
+If a community member engages in unacceptable behavior, the community organizers may take any action they deem appropriate, up to and including a temporary ban or permanent expulsion from the community without warning (and without refund in the case of a paid event).
+
+## 7. Reporting Guidelines
+
+If you are subject to or witness unacceptable behavior, or have any other concerns, please notify a community organizer as soon as possible. hi@coollabs.io.
+
+
+
+Additionally, community organizers are available to help community members engage with local law enforcement or to otherwise help those experiencing unacceptable behavior feel safe. In the context of in-person events, organizers will also provide escorts as desired by the person experiencing distress.
+
+## 8. Addressing Grievances
+
+If you feel you have been falsely or unfairly accused of violating this Code of Conduct, you should notify coollabsio with a concise description of your grievance. Your grievance will be handled in accordance with our existing governing policies. 
+
+
+
+## 9. Scope
+
+We expect all community participants (contributors, paid or otherwise; sponsors; and other guests) to abide by this Code of Conduct in all community venues--online and in-person--as well as in all one-on-one communications pertaining to community business.
+
+This code of conduct and its related procedures also applies to unacceptable behavior occurring outside the scope of community activities when such behavior has the potential to adversely affect the safety and well-being of community members.
+
+## 10. Contact info
+
+hi@coollabs.io
+
+## 11. License and attribution
+
+The Citizen Code of Conduct is distributed by [Stumptown Syndicate](http://stumptownsyndicate.org) under a [Creative Commons Attribution-ShareAlike license](http://creativecommons.org/licenses/by-sa/3.0/). 
+
+Portions of text derived from the [Django Code of Conduct](https://www.djangoproject.com/conduct/) and the [Geek Feminism Anti-Harassment Policy](http://geekfeminism.wikia.com/wiki/Conference_anti-harassment/Policy).
+
+_Revision 2.3. Posted 6 March 2017._
+
+_Revision 2.2. Posted 4 February 2016._
+
+_Revision 2.1. Posted 23 June 2014._
+
+_Revision 2.0, adopted by the [Stumptown Syndicate](http://stumptownsyndicate.org) board on 10 January 2013. Posted 17 March 2013._

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)

Dockerfile

@@ -1,30 +0,0 @@
-FROM node:16.14.0-alpine
-WORKDIR /app
-COPY package*.json .
-RUN yarn install
-COPY . .
-RUN yarn build
-
-FROM node:16.14.0-alpine
-WORKDIR /app
-
-LABEL coolify.managed true
-
-RUN apk add --no-cache git openssh-client curl jq cmake sqlite
-
-RUN curl -f https://get.pnpm.io/v6.16.js | node - add --global pnpm@6
-RUN pnpm add -g pnpm
-
-RUN curl -fsSL "https://download.docker.com/linux/static/stable/x86_64/docker-20.10.9.tgz" | tar -xzvf - docker/docker -C . --strip-components 1 && mv docker /usr/bin/docker
-RUN mkdir -p ~/.docker/cli-plugins/
-RUN curl -SL https://github.com/docker/compose/releases/download/v2.2.2/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose
-RUN chmod +x ~/.docker/cli-plugins/docker-compose
-
-COPY --from=0 /app/docker-compose.yaml .
-COPY --from=0 /app/build .
-COPY --from=0 /app/package.json .
-COPY --from=0 /app/node_modules ./node_modules
-COPY --from=0 /app/prisma ./prisma
-
-EXPOSE 3000
-CMD ["pnpm", "start"]

LICENSE

@@ -0,0 +1,201 @@
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2022] [Andras Bacsai]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,84 +1,147 @@
-# Coolify
+![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
+)
 
-An open-source & self-hostable Heroku / Netlify alternative.
+[![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)
 
-## Demo instance
+# About the Project
 
-https://demo.coolify.io/
+Coolify is an open-source & self-hostable alternative to Heroku / Netlify / Vercel / etc. 
 
-(If it is unresponsible, that means someone overloaded the server. 🙃)
+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.
 
-## Installation
+Imagine having the ease of a cloud but with your own servers. That is **Coolify**.
 
-Installation is automated with the following command:
+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 at [coolify.io](https://coolify.io).
+
+# Installation
 
 ```bash
-/bin/bash -c "$(curl -fsSL https://get.coollabs.io/coolify/install.sh)"
+curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
 ```
+You can find the installation script source [here](./scripts/install.sh).
 
-## Migration from v1
+# Support
 
-A fresh installation is necessary. v2 is not compatible with v1.
+Contact us at [coolify.io/docs/contact](https://coolify.io/docs/contact).
 
-## Features
-### Git Sources
-You can use the official ones or your self hosted version!
+# Donations
+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.
 
-- Github
-- GitLab
-- Bitbucket (WIP)
+[coolify.io/sponsorships](https://coolify.io/sponsorships)
 
-### Destinations
+Thank you so much!
 
-- Local Docker Engine
-- Remote Docker Engine (WIP)
-- Kubernetes (WIP)
+Special thanks to our biggest sponsors!
+
+### Special Sponsors
+
+![image](https://github.com/user-attachments/assets/c95a07df-7c5a-4e77-a35a-81f25fcbece1)
+
+* [CCCareers](https://cccareers.org/) - A career development platform connecting coding bootcamp graduates with job opportunities in the tech industry.
+* [Hetzner](http://htznr.li/CoolifyXHetzner) - A German web hosting company offering affordable dedicated servers, cloud services, and web hosting solutions.
+* [Logto](https://logto.io/?ref=coolify) - An open-source authentication and authorization solution for building secure login systems and managing user identities.
+* [BC Direct](https://bc.direct/?ref=coolify.io) - A digital marketing agency specializing in e-commerce solutions and online business growth strategies.
+* [QuantCDN](https://www.quantcdn.io/?ref=coolify.io) - A content delivery network (CDN) optimizing website performance through global content distribution.
+* [Arcjet](https://arcjet.com/?ref=coolify.io) - A cloud-based platform providing real-time protection against API abuse and bot attacks.
+* [SupaGuide](https://supa.guide/?ref=coolify.io) - A comprehensive resource hub offering guides and tutorials for web development using Supabase.
+* [Tigris](https://tigrisdata.com/?ref=coolify.io) - A fully managed serverless object storage service compatible with Amazon S3 API. Offers high performance, scalability, and built-in search capabilities for efficient data management.
+* [Fractal Networks](https://fractalnetworks.co/?ref=coolify.io) - A decentralized network infrastructure company focusing on secure and private communication solutions.
+* [Advin](https://coolify.ad.vin/?ref=coolify.io) - A digital advertising agency specializing in programmatic advertising and data-driven marketing strategies.
+* [Treive](https://trieve.ai/?ref=coolify.io) - An AI-powered search and discovery platform for enhancing information retrieval in large datasets.
+* [Blacksmith](https://blacksmith.sh/?ref=coolify.io) - A cloud-native platform for automating infrastructure provisioning and management across multiple cloud providers.
+* [Latitude](https://latitude.sh/?ref=coolify.io) - A cloud computing platform offering bare metal servers and cloud instances for developers and businesses.
+* [Brand Dev](https://brand.dev/?ref=coolify.io) - A web development agency specializing in creating custom digital experiences and brand identities.
+* [Jobscollider](https://jobscollider.com/remote-jobs?ref=coolify.io) - A job search platform connecting professionals with remote work opportunities across various industries.
+* [Hostinger](https://www.hostinger.com/vps/coolify-hosting?ref=coolify.io) - A web hosting provider offering affordable hosting solutions, domain registration, and website building tools.
+* [Glueops](https://www.glueops.dev/?ref=coolify.io) - A DevOps consulting company providing infrastructure automation and cloud optimization services.
+* [Ubicloud](https://ubicloud.com/?ref=coolify.io) - An open-source alternative to hyperscale cloud providers, offering high-performance cloud computing services.
+* [Juxtdigital](https://juxtdigital.dev/?ref=coolify.io) - A digital agency offering web development, design, and digital marketing services for businesses.
+* [Saasykit](https://saasykit.com/?ref=coolify.io) - A Laravel-based boilerplate providing essential components and features for building SaaS applications quickly.
+* [Massivegrid](https://massivegrid.com/?ref=coolify.io) - A cloud hosting provider offering scalable infrastructure solutions for businesses of all sizes.
 
 
-### Applications
+## Github Sponsors ($40+)
+<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/?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>
+<a href="https://github.com/Niki2k1"><img src="https://github.com/Niki2k1.png" width="60px" alt="Niklas Lausch" /></a>
+<a href="https://github.com/pixelinfinito"><img src="https://github.com/pixelinfinito.png" width="60px" alt="Pixel Infinito" /></a>
+<a href="https://github.com/whitesidest"><img src="https://avatars.githubusercontent.com/u/12365916?s=52&v=4" width="60px" alt="Tyler Whitesides" /></a>
+<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>
 
-- Static sites
-- NodeJS
-- VueJS
-- NuxtJS
-- NextJS
-- React/Preact
-- NextJS
-- Gatsby
-- Svelte
-- PHP
-- Rust
-- Dockerfile (you can provide it)
-
-### Databases
-
-- MongoDB
-- MySQL
-- PostgreSQL
-- CouchDB
-- Redis
-
-### One-click services
-
-- [WordPress](https://wordpress.org)
-- [Plausible Analytics](https://plausible.io)
-- [NocoDB](https://nocodb.com)
-- [VSCode Server](https://github.com/cdr/code-server)
-- [MinIO](https://min.io)
-- [VaultWarden](https://github.com/dani-garcia/vaultwarden)
+## Organizations
+<a href="https://opencollective.com/coollabsio/organization/0/website"><img src="https://opencollective.com/coollabsio/organization/0/avatar.svg"></a>
+<a href="https://opencollective.com/coollabsio/organization/1/website"><img src="https://opencollective.com/coollabsio/organization/1/avatar.svg"></a>
+<a href="https://opencollective.com/coollabsio/organization/2/website"><img src="https://opencollective.com/coollabsio/organization/2/avatar.svg"></a>
+<a href="https://opencollective.com/coollabsio/organization/3/website"><img src="https://opencollective.com/coollabsio/organization/3/avatar.svg"></a>
+<a href="https://opencollective.com/coollabsio/organization/4/website"><img src="https://opencollective.com/coollabsio/organization/4/avatar.svg"></a>
+<a href="https://opencollective.com/coollabsio/organization/5/website"><img src="https://opencollective.com/coollabsio/organization/5/avatar.svg"></a>
+<a href="https://opencollective.com/coollabsio/organization/6/website"><img src="https://opencollective.com/coollabsio/organization/6/avatar.svg"></a>
+<a href="https://opencollective.com/coollabsio/organization/7/website"><img src="https://opencollective.com/coollabsio/organization/7/avatar.svg"></a>
+<a href="https://opencollective.com/coollabsio/organization/8/website"><img src="https://opencollective.com/coollabsio/organization/8/avatar.svg"></a>
+<a href="https://opencollective.com/coollabsio/organization/9/website"><img src="https://opencollective.com/coollabsio/organization/9/avatar.svg"></a>
 
 
-## Support
+## Individuals
 
-- Twitter: [@andrasbacsai](https://twitter.com/andrasbacsai)
-- Telegram: [@andrasbacsai](https://t.me/andrasbacsai)
-- Email: [andras@coollabs.io](mailto:andras@coollabs.io)
-- Discord: [Invitation](https://discord.gg/xhBCC7eGKw)
+<a href="https://opencollective.com/coollabsio"><img src="https://opencollective.com/coollabsio/individuals.svg?width=890"></a>
 
-## Roadmap
+# Cloud
 
-[See the Roadmap here](https://github.com/orgs/coollabsio/projects/3/views/8)
+If you do not want to self-host Coolify, there is a paid cloud version available: [app.coolify.io](https://app.coolify.io)
 
-## License
+For more information & pricing, take a look at our landing page [coolify.io](https://coolify.io).
 
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Please see the [LICENSE](/LICENSE) file in our repository for the full text.
+## 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.
+
+By subscribing to the cloud version, you get the Coolify server for the same price, but with:
+- High-availability
+- Free email notifications
+- Better support
+- Less maintenance for you
+
+
+# Recognitions
+
+<p>
+<a href="https://news.ycombinator.com/item?id=26624341">
+  <img
+    style="width: 250px; height: 54px;" width="250" height="54"
+    alt="Featured on Hacker News"
+    src="https://hackernews-badge.vercel.app/api?id=26624341"
+  />
+</a>
+</p>
+
+<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>
+
+# Repo Activity
+
+![Alt](https://repobeats.axiom.co/api/embed/eab1c8066f9c59d0ad37b76c23ebb5ccac4278ae.svg "Repobeats analytics image")
+
+# Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=coollabsio/coolify&type=Date)](https://star-history.com/#coollabsio/coolify&Date)

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`).

SECURITY.md

@@ -0,0 +1,16 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| > 4   | :white_check_mark: |
+| 3   | :x:                |
+
+
+## Reporting a Vulnerability
+
+If you have any vulnerability please report at hi@coollabs.io

app/Actions/Application/GenerateConfig.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Actions\Application;
+
+use App\Models\Application;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class GenerateConfig
+{
+    use AsAction;
+
+    public function handle(Application $application, bool $is_json = false)
+    {
+        ray()->clearAll();
+        return $application->generateConfig(is_json: $is_json);
+    }
+}

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

@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Actions\Application;
+
+use App\Actions\Server\CleanupDocker;
+use App\Models\Application;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class StopApplication
+{
+    use AsAction;
+
+    public function handle(Application $application, bool $previewDeployments = false, bool $dockerCleanup = true)
+    {
+        try {
+            $server = $application->destination->server;
+            if (! $server->isFunctional()) {
+                return 'Server is not functional';
+            }
+            ray('Stopping application: '.$application->name);
+
+            if ($server->isSwarm()) {
+                instant_remote_process(["docker stack rm {$application->uuid}"], $server);
+
+                return;
+            }
+
+            $containersToStop = $application->getContainersToStop($previewDeployments);
+            $application->stopContainers($containersToStop, $server);
+
+            if ($application->build_pack === 'dockercompose') {
+                $application->delete_connected_networks($application->uuid);
+            }
+
+            if ($dockerCleanup) {
+                CleanupDocker::dispatch($server, true);
+            }
+        } catch (\Exception $e) {
+            ray($e->getMessage());
+
+            return $e->getMessage();
+        }
+    }
+}

app/Actions/Application/StopApplicationOneServer.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Actions\Application;
+
+use App\Models\Application;
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class StopApplicationOneServer
+{
+    use AsAction;
+
+    public function handle(Application $application, Server $server)
+    {
+        if ($application->destination->server->isSwarm()) {
+            return;
+        }
+        if (! $server->isFunctional()) {
+            return 'Server is not functional';
+        }
+        try {
+            $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
+                        );
+                    }
+                }
+            }
+        } catch (\Exception $e) {
+            ray($e->getMessage());
+
+            return $e->getMessage();
+        }
+    }
+}

app/Actions/CoolifyTask/PrepareCoolifyTask.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Actions\CoolifyTask;
+
+use App\Data\CoolifyTaskArgs;
+use App\Enums\ActivityTypes;
+use App\Jobs\CoolifyTask;
+use Spatie\Activitylog\Models\Activity;
+
+/**
+ * The initial step to run a `CoolifyTask`: a remote SSH process
+ * with monitoring/tracking/trace feature. Such thing is made
+ * possible using an Activity model and some attributes.
+ */
+class PrepareCoolifyTask
+{
+    protected Activity $activity;
+
+    protected CoolifyTaskArgs $remoteProcessArgs;
+
+    public function __construct(CoolifyTaskArgs $remoteProcessArgs)
+    {
+        $this->remoteProcessArgs = $remoteProcessArgs;
+
+        if ($remoteProcessArgs->model) {
+            $properties = $remoteProcessArgs->toArray();
+            unset($properties['model']);
+
+            $this->activity = activity()
+                ->withProperties($properties)
+                ->performedOn($remoteProcessArgs->model)
+                ->event($remoteProcessArgs->type)
+                ->log('[]');
+        } else {
+            $this->activity = activity()
+                ->withProperties($remoteProcessArgs->toArray())
+                ->event($remoteProcessArgs->type)
+                ->log('[]');
+        }
+    }
+
+    public function __invoke(): Activity
+    {
+        $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

@@ -0,0 +1,205 @@
+<?php
+
+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;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Process;
+use Spatie\Activitylog\Models\Activity;
+
+class RunRemoteProcess
+{
+    public Activity $activity;
+
+    public bool $hide_from_output;
+
+    public bool $ignore_errors;
+
+    public $call_event_on_finish = null;
+
+    public $call_event_data = null;
+
+    protected $time_start;
+
+    protected $current_time;
+
+    protected $last_write_at = 0;
+
+    protected $throttle_interval_ms = 200;
+
+    protected int $counter = 1;
+
+    /**
+     * Create a new job instance.
+     */
+    public function __construct(Activity $activity, bool $hide_from_output = false, bool $ignore_errors = false, $call_event_on_finish = null, $call_event_data = null)
+    {
+
+        if ($activity->getExtraProperty('type') !== ActivityTypes::INLINE->value && $activity->getExtraProperty('type') !== ActivityTypes::COMMAND->value) {
+            throw new \RuntimeException('Incompatible Activity to run a remote command.');
+        }
+
+        $this->activity = $activity;
+        $this->hide_from_output = $hide_from_output;
+        $this->ignore_errors = $ignore_errors;
+        $this->call_event_on_finish = $call_event_on_finish;
+        $this->call_event_data = $call_event_data;
+    }
+
+    public static function decodeOutput(?Activity $activity = null): string
+    {
+        if (is_null($activity)) {
+            return '';
+        }
+
+        try {
+            $decoded = json_decode(
+                data_get($activity, 'description'),
+                associative: true,
+                flags: JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE
+            );
+        } catch (\JsonException $exception) {
+            return '';
+        }
+
+        return collect($decoded)
+            ->sortBy(fn ($i) => $i['order'])
+            ->map(fn ($i) => $i['output'])
+            ->implode('');
+    }
+
+    public function __invoke(): ProcessResult
+    {
+        $this->time_start = hrtime(true);
+
+        $status = ProcessStatus::IN_PROGRESS;
+        $timeout = config('constants.ssh.command_timeout');
+        $process = Process::timeout($timeout)->start($this->getCommand(), $this->handleOutput(...));
+        $this->activity->properties = $this->activity->properties->merge([
+            'process_id' => $process->id(),
+        ]);
+
+        $processResult = $process->wait();
+        // $processResult = Process::timeout($timeout)->run($this->getCommand(), $this->handleOutput(...));
+        if ($this->activity->properties->get('status') === ProcessStatus::ERROR->value) {
+            $status = ProcessStatus::ERROR;
+        } else {
+            if ($processResult->exitCode() == 0) {
+                $status = ProcessStatus::FINISHED;
+            }
+            if ($processResult->exitCode() != 0 && ! $this->ignore_errors) {
+                $status = ProcessStatus::ERROR;
+            }
+            // if (($processResult->exitCode() == 0 && $this->is_finished) || $this->activity->properties->get('status') === ProcessStatus::FINISHED->value) {
+            //     $status = ProcessStatus::FINISHED;
+            // }
+            // if ($processResult->exitCode() != 0 && !$this->ignore_errors) {
+            //     $status = ProcessStatus::ERROR;
+            // }
+        }
+
+        $this->activity->properties = $this->activity->properties->merge([
+            'exitCode' => $processResult->exitCode(),
+            'stdout' => $processResult->output(),
+            'stderr' => $processResult->errorOutput(),
+            'status' => $status->value,
+        ]);
+        $this->activity->save();
+        if ($processResult->exitCode() != 0 && ! $this->ignore_errors) {
+            throw new \RuntimeException($processResult->errorOutput(), $processResult->exitCode());
+        }
+        if ($this->call_event_on_finish) {
+            try {
+                if ($this->call_event_data) {
+                    event(resolve("App\\Events\\$this->call_event_on_finish", [
+                        'data' => $this->call_event_data,
+                    ]));
+                } else {
+                    event(resolve("App\\Events\\$this->call_event_on_finish", [
+                        'userId' => $this->activity->causer_id,
+                    ]));
+                }
+            } catch (\Throwable $e) {
+                ray($e);
+            }
+        }
+
+        return $processResult;
+    }
+
+    protected function getCommand(): string
+    {
+        $server_uuid = $this->activity->getExtraProperty('server_uuid');
+        $command = $this->activity->getExtraProperty('command');
+        $server = Server::whereUuid($server_uuid)->firstOrFail();
+
+        return SshMultiplexingHelper::generateSshCommand($server, $command);
+    }
+
+    protected function handleOutput(string $type, string $output)
+    {
+        if ($this->hide_from_output) {
+            return;
+        }
+        $this->current_time = $this->elapsedTime();
+        $this->activity->description = $this->encodeOutput($type, $output);
+        if ($this->isAfterLastThrottle()) {
+            // Let's write to database.
+            DB::transaction(function () {
+                $this->activity->save();
+                $this->last_write_at = $this->current_time;
+            });
+        }
+    }
+
+    protected function elapsedTime(): int
+    {
+        $timeMs = (hrtime(true) - $this->time_start) / 1_000_000;
+
+        return intval($timeMs);
+    }
+
+    public function encodeOutput($type, $output)
+    {
+        $outputStack = json_decode($this->activity->description, associative: true, flags: JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE);
+        $outputStack[] = [
+            'type' => $type,
+            'output' => $output,
+            'timestamp' => hrtime(true),
+            'batch' => ApplicationDeploymentJob::$batch_counter,
+            'order' => $this->getLatestCounter(),
+        ];
+
+        return json_encode($outputStack, flags: JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE);
+    }
+
+    protected function getLatestCounter(): int
+    {
+        $description = json_decode($this->activity->description, associative: true, flags: JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE);
+        if ($description === null || count($description) === 0) {
+            return 1;
+        }
+
+        return end($description)['order'] + 1;
+    }
+
+    /**
+     * Determines if it's time to write again to database.
+     *
+     * @return bool
+     */
+    protected function isAfterLastThrottle()
+    {
+        // If DB was never written, then we immediately decide we have to write.
+        if ($this->last_write_at === 0) {
+            return true;
+        }
+
+        return ($this->current_time - $this->throttle_interval_ms) > $this->last_write_at;
+    }
+}

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

@@ -0,0 +1,167 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Models\StandaloneClickhouse;
+use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
+
+class StartClickhouse
+{
+    use AsAction;
+
+    public StandaloneClickhouse $database;
+
+    public array $commands = [];
+
+    public string $configuration_dir;
+
+    public function handle(StandaloneClickhouse $database)
+    {
+        $this->database = $database;
+
+        $container_name = $this->database->uuid;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
+
+        $this->commands = [
+            "echo 'Starting {$database->name}.'",
+            "mkdir -p $this->configuration_dir",
+        ];
+
+        $persistent_storages = $this->generate_local_persistent_volumes();
+        $persistent_file_volumes = $this->database->fileStorages()->get();
+        $volume_names = $this->generate_local_persistent_volumes_only_volume_names();
+        $environment_variables = $this->generate_environment_variables();
+
+        $docker_compose = [
+            'services' => [
+                $container_name => [
+                    'image' => $this->database->image,
+                    'container_name' => $container_name,
+                    'environment' => $environment_variables,
+                    'restart' => RESTART_MODE,
+                    'networks' => [
+                        $this->database->destination->network,
+                    ],
+                    'ulimits' => [
+                        'nofile' => [
+                            'soft' => 262144,
+                            'hard' => 262144,
+                        ],
+                    ],
+                    'labels' => [
+                        'coolify.managed' => 'true',
+                    ],
+                    'healthcheck' => [
+                        'test' => "clickhouse-client --password {$this->database->clickhouse_admin_password} --query 'SELECT 1'",
+                        'interval' => '5s',
+                        'timeout' => '5s',
+                        'retries' => 10,
+                        'start_period' => '5s',
+                    ],
+                    'mem_limit' => $this->database->limits_memory,
+                    'memswap_limit' => $this->database->limits_memory_swap,
+                    'mem_swappiness' => $this->database->limits_memory_swappiness,
+                    'mem_reservation' => $this->database->limits_memory_reservation,
+                    'cpus' => (float) $this->database->limits_cpus,
+                    'cpu_shares' => $this->database->limits_cpu_shares,
+                ],
+            ],
+            'networks' => [
+                $this->database->destination->network => [
+                    'external' => true,
+                    'name' => $this->database->destination->network,
+                    'attachable' => true,
+                ],
+            ],
+        ];
+        if (! is_null($this->database->limits_cpuset)) {
+            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'] = generate_fluentd_configuration();
+        }
+        if (count($this->database->ports_mappings_array) > 0) {
+            $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
+        }
+        if (count($persistent_storages) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_storages;
+        }
+        if (count($persistent_file_volumes) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_file_volumes->map(function ($item) {
+                return "$item->fs_path:$item->mount_path";
+            })->toArray();
+        }
+        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";
+        $readme = generate_readme_file($this->database->name, now());
+        $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
+        $this->commands[] = "echo 'Pulling {$database->image} image.'";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
+        $this->commands[] = "echo 'Database started.'";
+
+        return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
+    }
+
+    private function generate_local_persistent_volumes()
+    {
+        $local_persistent_volumes = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
+            } else {
+                $volume_name = $persistentStorage->name;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
+            }
+        }
+
+        return $local_persistent_volumes;
+    }
+
+    private function generate_local_persistent_volumes_only_volume_names()
+    {
+        $local_persistent_volumes_names = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path) {
+                continue;
+            }
+            $name = $persistentStorage->name;
+            $local_persistent_volumes_names[$name] = [
+                'name' => $name,
+                'external' => false,
+            ];
+        }
+
+        return $local_persistent_volumes_names;
+    }
+
+    private function generate_environment_variables()
+    {
+        $environment_variables = collect();
+        foreach ($this->database->runtime_environment_variables as $env) {
+            $environment_variables->push("$env->key=$env->real_value");
+        }
+
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('CLICKHOUSE_ADMIN_USER'))->isEmpty()) {
+            $environment_variables->push("CLICKHOUSE_ADMIN_USER={$this->database->clickhouse_admin_user}");
+        }
+
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('CLICKHOUSE_ADMIN_PASSWORD'))->isEmpty()) {
+            $environment_variables->push("CLICKHOUSE_ADMIN_PASSWORD={$this->database->clickhouse_admin_password}");
+        }
+
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
+        return $environment_variables->all();
+    }
+}

app/Actions/Database/StartDatabase.php

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

app/Actions/Database/StartDatabaseProxy.php

@@ -0,0 +1,158 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Models\ServiceDatabase;
+use App\Models\StandaloneClickhouse;
+use App\Models\StandaloneDragonfly;
+use App\Models\StandaloneKeydb;
+use App\Models\StandaloneMariadb;
+use App\Models\StandaloneMongodb;
+use App\Models\StandaloneMysql;
+use App\Models\StandalonePostgresql;
+use App\Models\StandaloneRedis;
+use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
+
+class StartDatabaseProxy
+{
+    use AsAction;
+
+    public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse|ServiceDatabase $database)
+    {
+        $internalPort = null;
+        $type = $database->getMorphClass();
+        $network = data_get($database, 'destination.network');
+        $server = data_get($database, 'destination.server');
+        $containerName = data_get($database, 'uuid');
+        $proxyContainerName = "{$database->uuid}-proxy";
+        if ($database->getMorphClass() === 'App\Models\ServiceDatabase') {
+            $databaseType = $database->databaseType();
+            // $connectPredefined = data_get($database, 'service.connect_to_docker_network');
+            $network = $database->service->uuid;
+            $server = data_get($database, 'service.destination.server');
+            $proxyContainerName = "{$database->service->uuid}-proxy";
+            switch ($databaseType) {
+                case 'standalone-mariadb':
+                    $type = 'App\Models\StandaloneMariadb';
+                    $containerName = "mariadb-{$database->service->uuid}";
+                    break;
+                case 'standalone-mongodb':
+                    $type = 'App\Models\StandaloneMongodb';
+                    $containerName = "mongodb-{$database->service->uuid}";
+                    break;
+                case 'standalone-mysql':
+                    $type = 'App\Models\StandaloneMysql';
+                    $containerName = "mysql-{$database->service->uuid}";
+                    break;
+                case 'standalone-postgresql':
+                    $type = 'App\Models\StandalonePostgresql';
+                    $containerName = "postgresql-{$database->service->uuid}";
+                    break;
+                case 'standalone-redis':
+                    $type = 'App\Models\StandaloneRedis';
+                    $containerName = "redis-{$database->service->uuid}";
+                    break;
+                case 'standalone-keydb':
+                    $type = 'App\Models\StandaloneKeydb';
+                    $containerName = "keydb-{$database->service->uuid}";
+                    break;
+                case 'standalone-dragonfly':
+                    $type = 'App\Models\StandaloneDragonfly';
+                    $containerName = "dragonfly-{$database->service->uuid}";
+                    break;
+                case 'standalone-clickhouse':
+                    $type = 'App\Models\StandaloneClickhouse';
+                    $containerName = "clickhouse-{$database->service->uuid}";
+                    break;
+            }
+        }
+        if ($type === 'App\Models\StandaloneRedis') {
+            $internalPort = 6379;
+        } elseif ($type === 'App\Models\StandalonePostgresql') {
+            $internalPort = 5432;
+        } elseif ($type === 'App\Models\StandaloneMongodb') {
+            $internalPort = 27017;
+        } elseif ($type === 'App\Models\StandaloneMysql') {
+            $internalPort = 3306;
+        } elseif ($type === 'App\Models\StandaloneMariadb') {
+            $internalPort = 3306;
+        } elseif ($type === 'App\Models\StandaloneKeydb') {
+            $internalPort = 6379;
+        } elseif ($type === 'App\Models\StandaloneDragonfly') {
+            $internalPort = 6379;
+        } elseif ($type === 'App\Models\StandaloneClickhouse') {
+            $internalPort = 9000;
+        }
+        $configuration_dir = database_proxy_dir($database->uuid);
+        $nginxconf = <<<EOF
+    user  nginx;
+    worker_processes  auto;
+
+    error_log  /var/log/nginx/error.log;
+
+    events {
+        worker_connections  1024;
+    }
+    stream {
+       server {
+            listen $database->public_port;
+            proxy_pass $containerName:$internalPort;
+       }
+    }
+    EOF;
+        $dockerfile = <<< 'EOF'
+    FROM nginx:stable-alpine
+
+    COPY nginx.conf /etc/nginx/nginx.conf
+    EOF;
+        $docker_compose = [
+            'services' => [
+                $proxyContainerName => [
+                    'build' => [
+                        'context' => $configuration_dir,
+                        'dockerfile' => 'Dockerfile',
+                    ],
+                    'image' => 'nginx:stable-alpine',
+                    'container_name' => $proxyContainerName,
+                    'restart' => RESTART_MODE,
+                    'ports' => [
+                        "$database->public_port:$database->public_port",
+                    ],
+                    'networks' => [
+                        $network,
+                    ],
+                    'healthcheck' => [
+                        'test' => [
+                            'CMD-SHELL',
+                            'stat /etc/nginx/nginx.conf || exit 1',
+                        ],
+                        'interval' => '5s',
+                        'timeout' => '5s',
+                        'retries' => 3,
+                        'start_period' => '1s',
+                    ],
+                ],
+            ],
+            'networks' => [
+                $network => [
+                    'external' => true,
+                    'name' => $network,
+                    'attachable' => true,
+                ],
+            ],
+        ];
+        $dockercompose_base64 = base64_encode(Yaml::dump($docker_compose, 4, 2));
+        $nginxconf_base64 = base64_encode($nginxconf);
+        $dockerfile_base64 = base64_encode($dockerfile);
+        instant_remote_process(["docker rm -f $proxyContainerName"], $server, false);
+        instant_remote_process([
+            "mkdir -p $configuration_dir",
+            "echo '{$dockerfile_base64}' | base64 -d | tee $configuration_dir/Dockerfile > /dev/null",
+            "echo '{$nginxconf_base64}' | base64 -d | tee $configuration_dir/nginx.conf > /dev/null",
+            "echo '{$dockercompose_base64}' | base64 -d | tee $configuration_dir/docker-compose.yaml > /dev/null",
+            "docker compose --project-directory {$configuration_dir} pull",
+            "docker compose --project-directory {$configuration_dir} up --build -d",
+        ], $server);
+    }
+}

app/Actions/Database/StartDragonfly.php

@@ -0,0 +1,158 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Models\StandaloneDragonfly;
+use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
+
+class StartDragonfly
+{
+    use AsAction;
+
+    public StandaloneDragonfly $database;
+
+    public array $commands = [];
+
+    public string $configuration_dir;
+
+    public function handle(StandaloneDragonfly $database)
+    {
+        $this->database = $database;
+
+        $startCommand = "dragonfly --requirepass {$this->database->dragonfly_password}";
+
+        $container_name = $this->database->uuid;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
+
+        $this->commands = [
+            "echo 'Starting {$database->name}.'",
+            "mkdir -p $this->configuration_dir",
+        ];
+
+        $persistent_storages = $this->generate_local_persistent_volumes();
+        $persistent_file_volumes = $this->database->fileStorages()->get();
+        $volume_names = $this->generate_local_persistent_volumes_only_volume_names();
+        $environment_variables = $this->generate_environment_variables();
+
+        $docker_compose = [
+            'services' => [
+                $container_name => [
+                    'image' => $this->database->image,
+                    'command' => $startCommand,
+                    'container_name' => $container_name,
+                    'environment' => $environment_variables,
+                    'restart' => RESTART_MODE,
+                    'networks' => [
+                        $this->database->destination->network,
+                    ],
+                    'labels' => [
+                        'coolify.managed' => 'true',
+                    ],
+                    'healthcheck' => [
+                        'test' => "redis-cli -a {$this->database->dragonfly_password} ping",
+                        'interval' => '5s',
+                        'timeout' => '5s',
+                        'retries' => 10,
+                        'start_period' => '5s',
+                    ],
+                    'mem_limit' => $this->database->limits_memory,
+                    'memswap_limit' => $this->database->limits_memory_swap,
+                    'mem_swappiness' => $this->database->limits_memory_swappiness,
+                    'mem_reservation' => $this->database->limits_memory_reservation,
+                    'cpus' => (float) $this->database->limits_cpus,
+                    'cpu_shares' => $this->database->limits_cpu_shares,
+                ],
+            ],
+            'networks' => [
+                $this->database->destination->network => [
+                    'external' => true,
+                    'name' => $this->database->destination->network,
+                    'attachable' => true,
+                ],
+            ],
+        ];
+        if (! is_null($this->database->limits_cpuset)) {
+            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'] = generate_fluentd_configuration();
+        }
+        if (count($this->database->ports_mappings_array) > 0) {
+            $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
+        }
+        if (count($persistent_storages) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_storages;
+        }
+        if (count($persistent_file_volumes) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_file_volumes->map(function ($item) {
+                return "$item->fs_path:$item->mount_path";
+            })->toArray();
+        }
+        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";
+        $readme = generate_readme_file($this->database->name, now());
+        $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
+        $this->commands[] = "echo 'Pulling {$database->image} image.'";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
+        $this->commands[] = "echo 'Database started.'";
+
+        return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
+    }
+
+    private function generate_local_persistent_volumes()
+    {
+        $local_persistent_volumes = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
+            } else {
+                $volume_name = $persistentStorage->name;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
+            }
+        }
+
+        return $local_persistent_volumes;
+    }
+
+    private function generate_local_persistent_volumes_only_volume_names()
+    {
+        $local_persistent_volumes_names = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path) {
+                continue;
+            }
+            $name = $persistentStorage->name;
+            $local_persistent_volumes_names[$name] = [
+                'name' => $name,
+                'external' => false,
+            ];
+        }
+
+        return $local_persistent_volumes_names;
+    }
+
+    private function generate_environment_variables()
+    {
+        $environment_variables = collect();
+        foreach ($this->database->runtime_environment_variables as $env) {
+            $environment_variables->push("$env->key=$env->real_value");
+        }
+
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
+            $environment_variables->push("REDIS_PASSWORD={$this->database->dragonfly_password}");
+        }
+
+        return $environment_variables->all();
+    }
+}

app/Actions/Database/StartKeydb.php

@@ -0,0 +1,182 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Models\StandaloneKeydb;
+use Illuminate\Support\Facades\Storage;
+use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
+
+class StartKeydb
+{
+    use AsAction;
+
+    public StandaloneKeydb $database;
+
+    public array $commands = [];
+
+    public string $configuration_dir;
+
+    public function handle(StandaloneKeydb $database)
+    {
+        $this->database = $database;
+
+        $startCommand = "keydb-server --requirepass {$this->database->keydb_password} --appendonly yes";
+
+        $container_name = $this->database->uuid;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
+
+        $this->commands = [
+            "echo 'Starting {$database->name}.'",
+            "mkdir -p $this->configuration_dir",
+        ];
+
+        $persistent_storages = $this->generate_local_persistent_volumes();
+        $persistent_file_volumes = $this->database->fileStorages()->get();
+        $volume_names = $this->generate_local_persistent_volumes_only_volume_names();
+        $environment_variables = $this->generate_environment_variables();
+        $this->add_custom_keydb();
+
+        $docker_compose = [
+            'services' => [
+                $container_name => [
+                    'image' => $this->database->image,
+                    'command' => $startCommand,
+                    'container_name' => $container_name,
+                    'environment' => $environment_variables,
+                    'restart' => RESTART_MODE,
+                    'networks' => [
+                        $this->database->destination->network,
+                    ],
+                    'labels' => [
+                        'coolify.managed' => 'true',
+                    ],
+                    'healthcheck' => [
+                        'test' => "keydb-cli --pass {$this->database->keydb_password} ping",
+                        'interval' => '5s',
+                        'timeout' => '5s',
+                        'retries' => 10,
+                        'start_period' => '5s',
+                    ],
+                    'mem_limit' => $this->database->limits_memory,
+                    'memswap_limit' => $this->database->limits_memory_swap,
+                    'mem_swappiness' => $this->database->limits_memory_swappiness,
+                    'mem_reservation' => $this->database->limits_memory_reservation,
+                    'cpus' => (float) $this->database->limits_cpus,
+                    'cpu_shares' => $this->database->limits_cpu_shares,
+                ],
+            ],
+            'networks' => [
+                $this->database->destination->network => [
+                    'external' => true,
+                    'name' => $this->database->destination->network,
+                    'attachable' => true,
+                ],
+            ],
+        ];
+        if (! is_null($this->database->limits_cpuset)) {
+            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'] = generate_fluentd_configuration();
+        }
+        if (count($this->database->ports_mappings_array) > 0) {
+            $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
+        }
+        if (count($persistent_storages) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_storages;
+        }
+        if (count($persistent_file_volumes) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_file_volumes->map(function ($item) {
+                return "$item->fs_path:$item->mount_path";
+            })->toArray();
+        }
+        if (count($volume_names) > 0) {
+            $docker_compose['volumes'] = $volume_names;
+        }
+        if (! is_null($this->database->keydb_conf) || ! empty($this->database->keydb_conf)) {
+            $docker_compose['services'][$container_name]['volumes'][] = [
+                'type' => 'bind',
+                'source' => $this->configuration_dir.'/keydb.conf',
+                'target' => '/etc/keydb/keydb.conf',
+                'read_only' => true,
+            ];
+            $docker_compose['services'][$container_name]['command'] = "keydb-server /etc/keydb/keydb.conf --requirepass {$this->database->keydb_password} --appendonly yes";
+        }
+
+        // Add custom docker run options
+        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
+        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+        $docker_compose = Yaml::dump($docker_compose, 10);
+        $docker_compose_base64 = base64_encode($docker_compose);
+        $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
+        $readme = generate_readme_file($this->database->name, now());
+        $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
+        $this->commands[] = "echo 'Pulling {$database->image} image.'";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
+        $this->commands[] = "echo 'Database started.'";
+
+        return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
+    }
+
+    private function generate_local_persistent_volumes()
+    {
+        $local_persistent_volumes = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
+            } else {
+                $volume_name = $persistentStorage->name;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
+            }
+        }
+
+        return $local_persistent_volumes;
+    }
+
+    private function generate_local_persistent_volumes_only_volume_names()
+    {
+        $local_persistent_volumes_names = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path) {
+                continue;
+            }
+            $name = $persistentStorage->name;
+            $local_persistent_volumes_names[$name] = [
+                'name' => $name,
+                'external' => false,
+            ];
+        }
+
+        return $local_persistent_volumes_names;
+    }
+
+    private function generate_environment_variables()
+    {
+        $environment_variables = collect();
+        foreach ($this->database->runtime_environment_variables as $env) {
+            $environment_variables->push("$env->key=$env->real_value");
+        }
+
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
+            $environment_variables->push("REDIS_PASSWORD={$this->database->keydb_password}");
+        }
+
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
+        return $environment_variables->all();
+    }
+
+    private function add_custom_keydb()
+    {
+        if (is_null($this->database->keydb_conf) || empty($this->database->keydb_conf)) {
+            return;
+        }
+        $filename = 'keydb.conf';
+        Storage::disk('local')->put("tmp/keydb.conf_{$this->database->uuid}", $this->database->keydb_conf);
+        $path = Storage::path("tmp/keydb.conf_{$this->database->uuid}");
+        instant_scp($path, "{$this->configuration_dir}/{$filename}", $this->database->destination->server);
+        Storage::disk('local')->delete("tmp/keydb.conf_{$this->database->uuid}");
+    }
+}

app/Actions/Database/StartMariadb.php

@@ -0,0 +1,187 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Models\StandaloneMariadb;
+use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
+
+class StartMariadb
+{
+    use AsAction;
+
+    public StandaloneMariadb $database;
+
+    public array $commands = [];
+
+    public string $configuration_dir;
+
+    public function handle(StandaloneMariadb $database)
+    {
+        $this->database = $database;
+
+        $container_name = $this->database->uuid;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
+
+        $this->commands = [
+            "echo 'Starting {$database->name}.'",
+            "mkdir -p $this->configuration_dir",
+        ];
+
+        $persistent_storages = $this->generate_local_persistent_volumes();
+        $persistent_file_volumes = $this->database->fileStorages()->get();
+        $volume_names = $this->generate_local_persistent_volumes_only_volume_names();
+        $environment_variables = $this->generate_environment_variables();
+        $this->add_custom_mysql();
+        $docker_compose = [
+            'services' => [
+                $container_name => [
+                    'image' => $this->database->image,
+                    'container_name' => $container_name,
+                    'environment' => $environment_variables,
+                    'restart' => RESTART_MODE,
+                    'networks' => [
+                        $this->database->destination->network,
+                    ],
+                    'labels' => [
+                        'coolify.managed' => 'true',
+                    ],
+                    'healthcheck' => [
+                        'test' => ['CMD', 'healthcheck.sh', '--connect', '--innodb_initialized'],
+                        'interval' => '5s',
+                        'timeout' => '5s',
+                        'retries' => 10,
+                        'start_period' => '5s',
+                    ],
+                    'mem_limit' => $this->database->limits_memory,
+                    'memswap_limit' => $this->database->limits_memory_swap,
+                    'mem_swappiness' => $this->database->limits_memory_swappiness,
+                    'mem_reservation' => $this->database->limits_memory_reservation,
+                    'cpus' => (float) $this->database->limits_cpus,
+                    'cpu_shares' => $this->database->limits_cpu_shares,
+                ],
+            ],
+            'networks' => [
+                $this->database->destination->network => [
+                    'external' => true,
+                    'name' => $this->database->destination->network,
+                    'attachable' => true,
+                ],
+            ],
+        ];
+        if (! is_null($this->database->limits_cpuset)) {
+            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'] = generate_fluentd_configuration();
+        }
+        if (count($this->database->ports_mappings_array) > 0) {
+            $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
+        }
+        if (count($persistent_storages) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_storages;
+        }
+        if (count($persistent_file_volumes) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_file_volumes->map(function ($item) {
+                return "$item->fs_path:$item->mount_path";
+            })->toArray();
+        }
+        if (count($volume_names) > 0) {
+            $docker_compose['volumes'] = $volume_names;
+        }
+        if (! is_null($this->database->mariadb_conf) || ! empty($this->database->mariadb_conf)) {
+            $docker_compose['services'][$container_name]['volumes'][] = [
+                'type' => 'bind',
+                'source' => $this->configuration_dir.'/custom-config.cnf',
+                'target' => '/etc/mysql/conf.d/custom-config.cnf',
+                'read_only' => true,
+            ];
+        }
+
+        // Add custom docker run options
+        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
+        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
+        $docker_compose = Yaml::dump($docker_compose, 10);
+        $docker_compose_base64 = base64_encode($docker_compose);
+        $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
+        $readme = generate_readme_file($this->database->name, now());
+        $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
+        $this->commands[] = "echo 'Pulling {$database->image} image.'";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
+        $this->commands[] = "echo 'Database started.'";
+
+        return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
+    }
+
+    private function generate_local_persistent_volumes()
+    {
+        $local_persistent_volumes = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
+            } else {
+                $volume_name = $persistentStorage->name;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
+            }
+        }
+
+        return $local_persistent_volumes;
+    }
+
+    private function generate_local_persistent_volumes_only_volume_names()
+    {
+        $local_persistent_volumes_names = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path) {
+                continue;
+            }
+            $name = $persistentStorage->name;
+            $local_persistent_volumes_names[$name] = [
+                'name' => $name,
+                'external' => false,
+            ];
+        }
+
+        return $local_persistent_volumes_names;
+    }
+
+    private function generate_environment_variables()
+    {
+        $environment_variables = collect();
+        foreach ($this->database->runtime_environment_variables as $env) {
+            $environment_variables->push("$env->key=$env->real_value");
+        }
+
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MARIADB_ROOT_PASSWORD'))->isEmpty()) {
+            $environment_variables->push("MARIADB_ROOT_PASSWORD={$this->database->mariadb_root_password}");
+        }
+
+        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($env)->contains('MARIADB_USER'))->isEmpty()) {
+            $environment_variables->push("MARIADB_USER={$this->database->mariadb_user}");
+        }
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MARIADB_PASSWORD'))->isEmpty()) {
+            $environment_variables->push("MARIADB_PASSWORD={$this->database->mariadb_password}");
+        }
+
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
+        return $environment_variables->all();
+    }
+
+    private function add_custom_mysql()
+    {
+        if (is_null($this->database->mariadb_conf) || empty($this->database->mariadb_conf)) {
+            return;
+        }
+        $filename = 'custom-config.cnf';
+        $content = $this->database->mariadb_conf;
+        $content_base64 = base64_encode($content);
+        $this->commands[] = "echo '{$content_base64}' | base64 -d | tee $this->configuration_dir/{$filename} > /dev/null";
+    }
+}

app/Actions/Database/StartMongodb.php

@@ -0,0 +1,208 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Models\StandaloneMongodb;
+use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
+
+class StartMongodb
+{
+    use AsAction;
+
+    public StandaloneMongodb $database;
+
+    public array $commands = [];
+
+    public string $configuration_dir;
+
+    public function handle(StandaloneMongodb $database)
+    {
+        $this->database = $database;
+
+        $startCommand = 'mongod';
+
+        $container_name = $this->database->uuid;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
+
+        $this->commands = [
+            "echo 'Starting {$database->name}.'",
+            "mkdir -p $this->configuration_dir",
+        ];
+
+        $persistent_storages = $this->generate_local_persistent_volumes();
+        $persistent_file_volumes = $this->database->fileStorages()->get();
+        $volume_names = $this->generate_local_persistent_volumes_only_volume_names();
+        $environment_variables = $this->generate_environment_variables();
+        $this->add_custom_mongo_conf();
+
+        $docker_compose = [
+            'services' => [
+                $container_name => [
+                    'image' => $this->database->image,
+                    'command' => $startCommand,
+                    'container_name' => $container_name,
+                    'environment' => $environment_variables,
+                    'restart' => RESTART_MODE,
+                    'networks' => [
+                        $this->database->destination->network,
+                    ],
+                    'labels' => [
+                        'coolify.managed' => 'true',
+                    ],
+                    'healthcheck' => [
+                        'test' => [
+                            'CMD',
+                            'echo',
+                            'ok',
+                        ],
+                        'interval' => '5s',
+                        'timeout' => '5s',
+                        'retries' => 10,
+                        'start_period' => '5s',
+                    ],
+                    'mem_limit' => $this->database->limits_memory,
+                    'memswap_limit' => $this->database->limits_memory_swap,
+                    'mem_swappiness' => $this->database->limits_memory_swappiness,
+                    'mem_reservation' => $this->database->limits_memory_reservation,
+                    'cpus' => (float) $this->database->limits_cpus,
+                    'cpu_shares' => $this->database->limits_cpu_shares,
+                ],
+            ],
+            'networks' => [
+                $this->database->destination->network => [
+                    'external' => true,
+                    'name' => $this->database->destination->network,
+                    'attachable' => true,
+                ],
+            ],
+        ];
+        if (! is_null($this->database->limits_cpuset)) {
+            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'] = generate_fluentd_configuration();
+        }
+        if (count($this->database->ports_mappings_array) > 0) {
+            $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
+        }
+        if (count($persistent_storages) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_storages;
+        }
+        if (count($persistent_file_volumes) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_file_volumes->map(function ($item) {
+                return "$item->fs_path:$item->mount_path";
+            })->toArray();
+        }
+        if (count($volume_names) > 0) {
+            $docker_compose['volumes'] = $volume_names;
+        }
+        if (! is_null($this->database->mongo_conf) || ! empty($this->database->mongo_conf)) {
+            $docker_compose['services'][$container_name]['volumes'][] = [
+                'type' => 'bind',
+                'source' => $this->configuration_dir.'/mongod.conf',
+                'target' => '/etc/mongo/mongod.conf',
+                'read_only' => true,
+            ];
+            $docker_compose['services'][$container_name]['command'] = $startCommand.' --config /etc/mongo/mongod.conf';
+        }
+        $this->add_default_database();
+        $docker_compose['services'][$container_name]['volumes'][] = [
+            'type' => 'bind',
+            'source' => $this->configuration_dir.'/docker-entrypoint-initdb.d',
+            'target' => '/docker-entrypoint-initdb.d',
+            'read_only' => true,
+        ];
+
+        // Add custom docker run options
+        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
+        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
+        $docker_compose = Yaml::dump($docker_compose, 10);
+        $docker_compose_base64 = base64_encode($docker_compose);
+        $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
+        $readme = generate_readme_file($this->database->name, now());
+        $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
+        $this->commands[] = "echo 'Pulling {$database->image} image.'";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
+        $this->commands[] = "echo 'Database started.'";
+
+        return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
+    }
+
+    private function generate_local_persistent_volumes()
+    {
+        $local_persistent_volumes = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
+            } else {
+                $volume_name = $persistentStorage->name;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
+            }
+        }
+
+        return $local_persistent_volumes;
+    }
+
+    private function generate_local_persistent_volumes_only_volume_names()
+    {
+        $local_persistent_volumes_names = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path) {
+                continue;
+            }
+            $name = $persistentStorage->name;
+            $local_persistent_volumes_names[$name] = [
+                'name' => $name,
+                'external' => false,
+            ];
+        }
+
+        return $local_persistent_volumes_names;
+    }
+
+    private function generate_environment_variables()
+    {
+        $environment_variables = collect();
+        foreach ($this->database->runtime_environment_variables as $env) {
+            $environment_variables->push("$env->key=$env->real_value");
+        }
+
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('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($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($env)->contains('MONGO_INITDB_DATABASE'))->isEmpty()) {
+            $environment_variables->push("MONGO_INITDB_DATABASE={$this->database->mongo_initdb_database}");
+        }
+
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
+        return $environment_variables->all();
+    }
+
+    private function add_custom_mongo_conf()
+    {
+        if (is_null($this->database->mongo_conf) || empty($this->database->mongo_conf)) {
+            return;
+        }
+        $filename = 'mongod.conf';
+        $content = $this->database->mongo_conf;
+        $content_base64 = base64_encode($content);
+        $this->commands[] = "echo '{$content_base64}' | base64 -d | tee $this->configuration_dir/{$filename} > /dev/null";
+    }
+
+    private function add_default_database()
+    {
+        $content = "db = db.getSiblingDB(\"{$this->database->mongo_initdb_database}\");db.createCollection('init_collection');db.createUser({user: \"{$this->database->mongo_initdb_root_username}\", pwd: \"{$this->database->mongo_initdb_root_password}\",roles: [{role:\"readWrite\",db:\"{$this->database->mongo_initdb_database}\"}]});";
+        $content_base64 = base64_encode($content);
+        $this->commands[] = "mkdir -p $this->configuration_dir/docker-entrypoint-initdb.d";
+        $this->commands[] = "echo '{$content_base64}' | base64 -d | tee $this->configuration_dir/docker-entrypoint-initdb.d/01-default-database.js > /dev/null";
+    }
+}

app/Actions/Database/StartMysql.php

@@ -0,0 +1,187 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Models\StandaloneMysql;
+use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
+
+class StartMysql
+{
+    use AsAction;
+
+    public StandaloneMysql $database;
+
+    public array $commands = [];
+
+    public string $configuration_dir;
+
+    public function handle(StandaloneMysql $database)
+    {
+        $this->database = $database;
+
+        $container_name = $this->database->uuid;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
+
+        $this->commands = [
+            "echo 'Starting {$database->name}.'",
+            "mkdir -p $this->configuration_dir",
+        ];
+
+        $persistent_storages = $this->generate_local_persistent_volumes();
+        $persistent_file_volumes = $this->database->fileStorages()->get();
+        $volume_names = $this->generate_local_persistent_volumes_only_volume_names();
+        $environment_variables = $this->generate_environment_variables();
+        $this->add_custom_mysql();
+        $docker_compose = [
+            'services' => [
+                $container_name => [
+                    'image' => $this->database->image,
+                    'container_name' => $container_name,
+                    'environment' => $environment_variables,
+                    'restart' => RESTART_MODE,
+                    'networks' => [
+                        $this->database->destination->network,
+                    ],
+                    'labels' => [
+                        'coolify.managed' => 'true',
+                    ],
+                    'healthcheck' => [
+                        'test' => ['CMD', 'mysqladmin', 'ping', '-h', 'localhost', '-u', 'root', "-p{$this->database->mysql_root_password}"],
+                        'interval' => '5s',
+                        'timeout' => '5s',
+                        'retries' => 10,
+                        'start_period' => '5s',
+                    ],
+                    'mem_limit' => $this->database->limits_memory,
+                    'memswap_limit' => $this->database->limits_memory_swap,
+                    'mem_swappiness' => $this->database->limits_memory_swappiness,
+                    'mem_reservation' => $this->database->limits_memory_reservation,
+                    'cpus' => (float) $this->database->limits_cpus,
+                    'cpu_shares' => $this->database->limits_cpu_shares,
+                ],
+            ],
+            'networks' => [
+                $this->database->destination->network => [
+                    'external' => true,
+                    'name' => $this->database->destination->network,
+                    'attachable' => true,
+                ],
+            ],
+        ];
+        if (! is_null($this->database->limits_cpuset)) {
+            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'] = generate_fluentd_configuration();
+        }
+        if (count($this->database->ports_mappings_array) > 0) {
+            $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
+        }
+        if (count($persistent_storages) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_storages;
+        }
+        if (count($persistent_file_volumes) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_file_volumes->map(function ($item) {
+                return "$item->fs_path:$item->mount_path";
+            })->toArray();
+        }
+        if (count($volume_names) > 0) {
+            $docker_compose['volumes'] = $volume_names;
+        }
+        if (! is_null($this->database->mysql_conf) || ! empty($this->database->mysql_conf)) {
+            $docker_compose['services'][$container_name]['volumes'][] = [
+                'type' => 'bind',
+                'source' => $this->configuration_dir.'/custom-config.cnf',
+                'target' => '/etc/mysql/conf.d/custom-config.cnf',
+                'read_only' => true,
+            ];
+        }
+
+        // Add custom docker run options
+        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
+        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
+        $docker_compose = Yaml::dump($docker_compose, 10);
+        $docker_compose_base64 = base64_encode($docker_compose);
+        $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
+        $readme = generate_readme_file($this->database->name, now());
+        $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
+        $this->commands[] = "echo 'Pulling {$database->image} image.'";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
+        $this->commands[] = "echo 'Database started.'";
+
+        return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
+    }
+
+    private function generate_local_persistent_volumes()
+    {
+        $local_persistent_volumes = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
+            } else {
+                $volume_name = $persistentStorage->name;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
+            }
+        }
+
+        return $local_persistent_volumes;
+    }
+
+    private function generate_local_persistent_volumes_only_volume_names()
+    {
+        $local_persistent_volumes_names = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path) {
+                continue;
+            }
+            $name = $persistentStorage->name;
+            $local_persistent_volumes_names[$name] = [
+                'name' => $name,
+                'external' => false,
+            ];
+        }
+
+        return $local_persistent_volumes_names;
+    }
+
+    private function generate_environment_variables()
+    {
+        $environment_variables = collect();
+        foreach ($this->database->runtime_environment_variables as $env) {
+            $environment_variables->push("$env->key=$env->real_value");
+        }
+
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MYSQL_ROOT_PASSWORD'))->isEmpty()) {
+            $environment_variables->push("MYSQL_ROOT_PASSWORD={$this->database->mysql_root_password}");
+        }
+
+        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($env)->contains('MYSQL_USER'))->isEmpty()) {
+            $environment_variables->push("MYSQL_USER={$this->database->mysql_user}");
+        }
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MYSQL_PASSWORD'))->isEmpty()) {
+            $environment_variables->push("MYSQL_PASSWORD={$this->database->mysql_password}");
+        }
+
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
+        return $environment_variables->all();
+    }
+
+    private function add_custom_mysql()
+    {
+        if (is_null($this->database->mysql_conf) || empty($this->database->mysql_conf)) {
+            return;
+        }
+        $filename = 'custom-config.cnf';
+        $content = $this->database->mysql_conf;
+        $content_base64 = base64_encode($content);
+        $this->commands[] = "echo '{$content_base64}' | base64 -d | tee $this->configuration_dir/{$filename} > /dev/null";
+    }
+}

app/Actions/Database/StartPostgresql.php

@@ -0,0 +1,227 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Models\StandalonePostgresql;
+use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
+
+class StartPostgresql
+{
+    use AsAction;
+
+    public StandalonePostgresql $database;
+
+    public array $commands = [];
+
+    public array $init_scripts = [];
+
+    public string $configuration_dir;
+
+    public function handle(StandalonePostgresql $database)
+    {
+        $this->database = $database;
+        $container_name = $this->database->uuid;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
+
+        $this->commands = [
+            "echo 'Starting {$database->name}.'",
+            "mkdir -p $this->configuration_dir",
+            "mkdir -p $this->configuration_dir/docker-entrypoint-initdb.d/",
+        ];
+
+        $persistent_storages = $this->generate_local_persistent_volumes();
+        $persistent_file_volumes = $this->database->fileStorages()->get();
+        $volume_names = $this->generate_local_persistent_volumes_only_volume_names();
+        $environment_variables = $this->generate_environment_variables();
+        $this->generate_init_scripts();
+        $this->add_custom_conf();
+
+        $docker_compose = [
+            'services' => [
+                $container_name => [
+                    'image' => $this->database->image,
+                    'container_name' => $container_name,
+                    'environment' => $environment_variables,
+                    'restart' => RESTART_MODE,
+                    'networks' => [
+                        $this->database->destination->network,
+                    ],
+                    'labels' => [
+                        'coolify.managed' => 'true',
+                    ],
+                    'healthcheck' => [
+                        'test' => [
+                            'CMD-SHELL',
+                            "psql -U {$this->database->postgres_user} -d {$this->database->postgres_db} -c 'SELECT 1' || exit 1",
+                        ],
+                        'interval' => '5s',
+                        'timeout' => '5s',
+                        'retries' => 10,
+                        'start_period' => '5s',
+                    ],
+                    'mem_limit' => $this->database->limits_memory,
+                    'memswap_limit' => $this->database->limits_memory_swap,
+                    'mem_swappiness' => $this->database->limits_memory_swappiness,
+                    'mem_reservation' => $this->database->limits_memory_reservation,
+                    'cpus' => (float) $this->database->limits_cpus,
+                    'cpu_shares' => $this->database->limits_cpu_shares,
+                ],
+            ],
+            'networks' => [
+                $this->database->destination->network => [
+                    'external' => true,
+                    'name' => $this->database->destination->network,
+                    'attachable' => true,
+                ],
+            ],
+        ];
+        if (! is_null($this->database->limits_cpuset)) {
+            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'] = generate_fluentd_configuration();
+        }
+        if (count($this->database->ports_mappings_array) > 0) {
+            $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
+        }
+        if (count($persistent_storages) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_storages;
+        }
+        if (count($persistent_file_volumes) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_file_volumes->map(function ($item) {
+                return "$item->fs_path:$item->mount_path";
+            })->toArray();
+        }
+        if (count($volume_names) > 0) {
+            $docker_compose['volumes'] = $volume_names;
+        }
+        if (count($this->init_scripts) > 0) {
+            foreach ($this->init_scripts as $init_script) {
+                $docker_compose['services'][$container_name]['volumes'][] = [
+                    'type' => 'bind',
+                    'source' => $init_script,
+                    'target' => '/docker-entrypoint-initdb.d/'.basename($init_script),
+                    'read_only' => true,
+                ];
+            }
+        }
+        if (! is_null($this->database->postgres_conf) && ! empty($this->database->postgres_conf)) {
+            $docker_compose['services'][$container_name]['volumes'][] = [
+                'type' => 'bind',
+                'source' => $this->configuration_dir.'/custom-postgres.conf',
+                'target' => '/etc/postgresql/postgresql.conf',
+                'read_only' => true,
+            ];
+            $docker_compose['services'][$container_name]['command'] = [
+                'postgres',
+                '-c',
+                '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";
+        $readme = generate_readme_file($this->database->name, now());
+        $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
+        $this->commands[] = "echo 'Pulling {$database->image} image.'";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
+        $this->commands[] = "echo 'Database started.'";
+
+        return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
+    }
+
+    private function generate_local_persistent_volumes()
+    {
+        $local_persistent_volumes = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
+            } else {
+                $volume_name = $persistentStorage->name;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
+            }
+        }
+
+        return $local_persistent_volumes;
+    }
+
+    private function generate_local_persistent_volumes_only_volume_names()
+    {
+        $local_persistent_volumes_names = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path) {
+                continue;
+            }
+            $name = $persistentStorage->name;
+            $local_persistent_volumes_names[$name] = [
+                'name' => $name,
+                'external' => false,
+            ];
+        }
+
+        return $local_persistent_volumes_names;
+    }
+
+    private function generate_environment_variables()
+    {
+        $environment_variables = collect();
+        foreach ($this->database->runtime_environment_variables as $env) {
+            $environment_variables->push("$env->key=$env->real_value");
+        }
+
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('POSTGRES_USER'))->isEmpty()) {
+            $environment_variables->push("POSTGRES_USER={$this->database->postgres_user}");
+        }
+        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($env)->contains('POSTGRES_PASSWORD'))->isEmpty()) {
+            $environment_variables->push("POSTGRES_PASSWORD={$this->database->postgres_password}");
+        }
+
+        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();
+    }
+
+    private function generate_init_scripts()
+    {
+        if (is_null($this->database->init_scripts) || count($this->database->init_scripts) === 0) {
+            return;
+        }
+        foreach ($this->database->init_scripts as $init_script) {
+            $filename = data_get($init_script, 'filename');
+            $content = data_get($init_script, 'content');
+            $content_base64 = base64_encode($content);
+            $this->commands[] = "echo '{$content_base64}' | base64 -d | tee $this->configuration_dir/docker-entrypoint-initdb.d/{$filename} > /dev/null";
+            $this->init_scripts[] = "$this->configuration_dir/docker-entrypoint-initdb.d/{$filename}";
+        }
+    }
+
+    private function add_custom_conf()
+    {
+        if (is_null($this->database->postgres_conf) || empty($this->database->postgres_conf)) {
+            return;
+        }
+        $filename = 'custom-postgres.conf';
+        $content = $this->database->postgres_conf;
+        if (! str($content)->contains('listen_addresses')) {
+            $content .= "\nlisten_addresses = '*'";
+            $this->database->postgres_conf = $content;
+            $this->database->save();
+        }
+        $content_base64 = base64_encode($content);
+        $this->commands[] = "echo '{$content_base64}' | base64 -d | tee $this->configuration_dir/{$filename} > /dev/null";
+    }
+}

app/Actions/Database/StartRedis.php

@@ -0,0 +1,187 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Models\StandaloneRedis;
+use Illuminate\Support\Facades\Storage;
+use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
+
+class StartRedis
+{
+    use AsAction;
+
+    public StandaloneRedis $database;
+
+    public array $commands = [];
+
+    public string $configuration_dir;
+
+    public function handle(StandaloneRedis $database)
+    {
+        $this->database = $database;
+
+        $startCommand = "redis-server --requirepass {$this->database->redis_password} --appendonly yes";
+
+        $container_name = $this->database->uuid;
+        $this->configuration_dir = database_configuration_dir().'/'.$container_name;
+
+        $this->commands = [
+            "echo 'Starting {$database->name}.'",
+            "mkdir -p $this->configuration_dir",
+        ];
+
+        $persistent_storages = $this->generate_local_persistent_volumes();
+        $persistent_file_volumes = $this->database->fileStorages()->get();
+        $volume_names = $this->generate_local_persistent_volumes_only_volume_names();
+        $environment_variables = $this->generate_environment_variables();
+        $this->add_custom_redis();
+
+        $docker_compose = [
+            'services' => [
+                $container_name => [
+                    'image' => $this->database->image,
+                    'command' => $startCommand,
+                    'container_name' => $container_name,
+                    'environment' => $environment_variables,
+                    'restart' => RESTART_MODE,
+                    'networks' => [
+                        $this->database->destination->network,
+                    ],
+                    'labels' => [
+                        'coolify.managed' => 'true',
+                    ],
+                    'healthcheck' => [
+                        'test' => [
+                            'CMD-SHELL',
+                            'redis-cli',
+                            'ping',
+                        ],
+                        'interval' => '5s',
+                        'timeout' => '5s',
+                        'retries' => 10,
+                        'start_period' => '5s',
+                    ],
+                    'mem_limit' => $this->database->limits_memory,
+                    'memswap_limit' => $this->database->limits_memory_swap,
+                    'mem_swappiness' => $this->database->limits_memory_swappiness,
+                    'mem_reservation' => $this->database->limits_memory_reservation,
+                    'cpus' => (float) $this->database->limits_cpus,
+                    'cpu_shares' => $this->database->limits_cpu_shares,
+                ],
+            ],
+            'networks' => [
+                $this->database->destination->network => [
+                    'external' => true,
+                    'name' => $this->database->destination->network,
+                    'attachable' => true,
+                ],
+            ],
+        ];
+        if (! is_null($this->database->limits_cpuset)) {
+            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'] = generate_fluentd_configuration();
+        }
+        if (count($this->database->ports_mappings_array) > 0) {
+            $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
+        }
+        if (count($persistent_storages) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_storages;
+        }
+        if (count($persistent_file_volumes) > 0) {
+            $docker_compose['services'][$container_name]['volumes'] = $persistent_file_volumes->map(function ($item) {
+                return "$item->fs_path:$item->mount_path";
+            })->toArray();
+        }
+        if (count($volume_names) > 0) {
+            $docker_compose['volumes'] = $volume_names;
+        }
+        if (! is_null($this->database->redis_conf) || ! empty($this->database->redis_conf)) {
+            $docker_compose['services'][$container_name]['volumes'][] = [
+                'type' => 'bind',
+                'source' => $this->configuration_dir.'/redis.conf',
+                'target' => '/usr/local/etc/redis/redis.conf',
+                'read_only' => true,
+            ];
+            $docker_compose['services'][$container_name]['command'] = "redis-server /usr/local/etc/redis/redis.conf --requirepass {$this->database->redis_password} --appendonly yes";
+        }
+
+        // Add custom docker run options
+        $docker_run_options = convert_docker_run_to_compose($this->database->custom_docker_run_options);
+        $docker_compose = generate_custom_docker_run_options_for_databases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
+        $docker_compose = Yaml::dump($docker_compose, 10);
+        $docker_compose_base64 = base64_encode($docker_compose);
+        $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
+        $readme = generate_readme_file($this->database->name, now());
+        $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
+        $this->commands[] = "echo 'Pulling {$database->image} image.'";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
+        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
+        $this->commands[] = "echo 'Database started.'";
+
+        return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
+    }
+
+    private function generate_local_persistent_volumes()
+    {
+        $local_persistent_volumes = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
+                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
+            } else {
+                $volume_name = $persistentStorage->name;
+                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
+            }
+        }
+
+        return $local_persistent_volumes;
+    }
+
+    private function generate_local_persistent_volumes_only_volume_names()
+    {
+        $local_persistent_volumes_names = [];
+        foreach ($this->database->persistentStorages as $persistentStorage) {
+            if ($persistentStorage->host_path) {
+                continue;
+            }
+            $name = $persistentStorage->name;
+            $local_persistent_volumes_names[$name] = [
+                'name' => $name,
+                'external' => false,
+            ];
+        }
+
+        return $local_persistent_volumes_names;
+    }
+
+    private function generate_environment_variables()
+    {
+        $environment_variables = collect();
+        foreach ($this->database->runtime_environment_variables as $env) {
+            $environment_variables->push("$env->key=$env->real_value");
+        }
+
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
+            $environment_variables->push("REDIS_PASSWORD={$this->database->redis_password}");
+        }
+
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
+        return $environment_variables->all();
+    }
+
+    private function add_custom_redis()
+    {
+        if (is_null($this->database->redis_conf) || empty($this->database->redis_conf)) {
+            return;
+        }
+        $filename = 'redis.conf';
+        Storage::disk('local')->put("tmp/redis.conf_{$this->database->uuid}", $this->database->redis_conf);
+        $path = Storage::path("tmp/redis.conf_{$this->database->uuid}");
+        instant_scp($path, "{$this->configuration_dir}/{$filename}", $this->database->destination->server);
+        Storage::disk('local')->delete("tmp/redis.conf_{$this->database->uuid}");
+    }
+}

app/Actions/Database/StopDatabase.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Actions\Server\CleanupDocker;
+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 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, bool $isDeleteOperation = false, bool $dockerCleanup = true)
+    {
+        $server = $database->destination->server;
+        if (! $server->isFunctional()) {
+            return 'Server is not functional';
+        }
+
+        $this->stopContainer($database, $database->uuid, 300);
+        if (! $isDeleteOperation) {
+            if ($dockerCleanup) {
+                CleanupDocker::dispatch($server, true);
+            }
+        }
+
+        if ($database->is_public) {
+            StopDatabaseProxy::run($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

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Events\DatabaseStatusChanged;
+use App\Models\ServiceDatabase;
+use App\Models\StandaloneClickhouse;
+use App\Models\StandaloneDragonfly;
+use App\Models\StandaloneKeydb;
+use App\Models\StandaloneMariadb;
+use App\Models\StandaloneMongodb;
+use App\Models\StandaloneMysql;
+use App\Models\StandalonePostgresql;
+use App\Models\StandaloneRedis;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class StopDatabaseProxy
+{
+    use AsAction;
+
+    public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|ServiceDatabase|StandaloneDragonfly|StandaloneClickhouse $database)
+    {
+        $server = data_get($database, 'destination.server');
+        $uuid = $database->uuid;
+        if ($database->getMorphClass() === 'App\Models\ServiceDatabase') {
+            $uuid = $database->service->uuid;
+            $server = data_get($database, 'service.server');
+        }
+        instant_remote_process(["docker rm -f {$uuid}-proxy"], $server);
+        $database->save();
+        DatabaseStatusChanged::dispatch();
+    }
+}

app/Actions/Docker/GetContainersStatus.php

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

app/Actions/Fortify/CreateNewUser.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace App\Actions\Fortify;
+
+use App\Models\User;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Validation\Rule;
+use Laravel\Fortify\Contracts\CreatesNewUsers;
+
+class CreateNewUser implements CreatesNewUsers
+{
+    use PasswordValidationRules;
+
+    /**
+     * Validate and create a newly registered user.
+     *
+     * @param  array<string, string>  $input
+     */
+    public function create(array $input): User
+    {
+        $settings = instanceSettings();
+        if (! $settings->is_registration_enabled) {
+            abort(403);
+        }
+        Validator::make($input, [
+            'name' => ['required', 'string', 'max:255'],
+            'email' => [
+                'required',
+                'string',
+                'email',
+                'max:255',
+                Rule::unique(User::class),
+            ],
+            'password' => $this->passwordRules(),
+        ])->validate();
+
+        if (User::count() == 0) {
+            // If this is the first user, make them the root user
+            // Team is already created in the database/seeders/ProductionSeeder.php
+            $user = User::create([
+                'id' => 0,
+                'name' => $input['name'],
+                'email' => $input['email'],
+                'password' => Hash::make($input['password']),
+            ]);
+            $team = $user->teams()->first();
+
+            // Disable registration after first user is created
+            $settings = instanceSettings();
+            $settings->is_registration_enabled = false;
+            $settings->save();
+        } else {
+            $user = User::create([
+                'name' => $input['name'],
+                'email' => $input['email'],
+                'password' => Hash::make($input['password']),
+            ]);
+            $team = $user->teams()->first();
+            if (isCloud()) {
+                $user->sendVerificationEmail();
+            } else {
+                $user->markEmailAsVerified();
+            }
+        }
+        // Set session variable
+        session(['currentTeam' => $user->currentTeam = $team]);
+
+        return $user;
+    }
+}

app/Actions/Fortify/PasswordValidationRules.php

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

app/Actions/Fortify/ResetUserPassword.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Actions\Fortify;
+
+use App\Models\User;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Validator;
+use Laravel\Fortify\Contracts\ResetsUserPasswords;
+
+class ResetUserPassword implements ResetsUserPasswords
+{
+    use PasswordValidationRules;
+
+    /**
+     * Validate and reset the user's forgotten password.
+     *
+     * @param  array<string, string>  $input
+     */
+    public function reset(User $user, array $input): void
+    {
+        Validator::make($input, [
+            'password' => $this->passwordRules(),
+        ])->validate();
+
+        $user->forceFill([
+            'password' => Hash::make($input['password']),
+        ])->save();
+    }
+}

app/Actions/Fortify/UpdateUserPassword.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Actions\Fortify;
+
+use App\Models\User;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Validator;
+use Laravel\Fortify\Contracts\UpdatesUserPasswords;
+
+class UpdateUserPassword implements UpdatesUserPasswords
+{
+    use PasswordValidationRules;
+
+    /**
+     * Validate and update the user's password.
+     *
+     * @param  array<string, string>  $input
+     */
+    public function update(User $user, array $input): void
+    {
+        Validator::make($input, [
+            'current_password' => ['required', 'string', 'current_password:web'],
+            'password' => $this->passwordRules(),
+        ], [
+            'current_password.current_password' => __('The provided password does not match your current password.'),
+        ])->validateWithBag('updatePassword');
+
+        $user->forceFill([
+            'password' => Hash::make($input['password']),
+        ])->save();
+    }
+}

app/Actions/Fortify/UpdateUserProfileInformation.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Actions\Fortify;
+
+use App\Models\User;
+use Illuminate\Contracts\Auth\MustVerifyEmail;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Validation\Rule;
+use Laravel\Fortify\Contracts\UpdatesUserProfileInformation;
+
+class UpdateUserProfileInformation implements UpdatesUserProfileInformation
+{
+    /**
+     * Validate and update the given user's profile information.
+     *
+     * @param  array<string, string>  $input
+     */
+    public function update(User $user, array $input): void
+    {
+        Validator::make($input, [
+            'name' => ['required', 'string', 'max:255'],
+
+            'email' => [
+                'required',
+                'string',
+                'email',
+                'max:255',
+                Rule::unique('users')->ignore($user->id),
+            ],
+        ])->validateWithBag('updateProfileInformation');
+
+        if (
+            $input['email'] !== $user->email &&
+            $user instanceof MustVerifyEmail
+        ) {
+            $this->updateVerifiedUser($user, $input);
+        } else {
+            $user->forceFill([
+                'name' => $input['name'],
+                'email' => $input['email'],
+            ])->save();
+        }
+    }
+
+    /**
+     * Update the given verified user's profile information.
+     *
+     * @param  array<string, string>  $input
+     */
+    protected function updateVerifiedUser(User $user, array $input): void
+    {
+        $user->forceFill([
+            'name' => $input['name'],
+            'email' => $input['email'],
+            'email_verified_at' => null,
+        ])->save();
+
+        $user->sendEmailVerificationNotification();
+    }
+}

app/Actions/License/CheckResaleLicense.php

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

app/Actions/Proxy/CheckConfiguration.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Actions\Proxy;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class CheckConfiguration
+{
+    use AsAction;
+
+    public function handle(Server $server, bool $reset = false)
+    {
+        $proxyType = $server->proxyType();
+        if ($proxyType === 'NONE') {
+            return 'OK';
+        }
+        $proxy_path = $server->proxyPath();
+        $payload = [
+            "mkdir -p $proxy_path",
+            "cat $proxy_path/docker-compose.yml",
+        ];
+        $proxy_configuration = instant_remote_process($payload, $server, false);
+        if ($reset || ! $proxy_configuration || is_null($proxy_configuration)) {
+            $proxy_configuration = str(generate_default_proxy_configuration($server))->trim()->value();
+        }
+        if (! $proxy_configuration || is_null($proxy_configuration)) {
+            throw new \Exception('Could not generate proxy configuration');
+        }
+
+        return $proxy_configuration;
+    }
+}

app/Actions/Proxy/CheckProxy.php

@@ -0,0 +1,110 @@
+<?php
+
+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;
+
+    // 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;
+        }
+        if ($server->isBuildServer()) {
+            if ($server->proxy) {
+                $server->proxy = null;
+                $server->save();
+            }
+
+            return false;
+        }
+        $proxyType = $server->proxyType();
+        if (is_null($proxyType) || $proxyType === 'NONE' || $server->proxy->force_stop) {
+            return false;
+        }
+        ['uptime' => $uptime, 'error' => $error] = $server->validateConnection(false);
+        if (! $uptime) {
+            throw new \Exception($error);
+        }
+        if (! $server->isProxyShouldRun()) {
+            if ($fromUI) {
+                throw new \Exception('Proxy should not run. You selected the Custom Proxy.');
+            } else {
+                return false;
+            }
+        }
+        if ($server->isSwarm()) {
+            $status = getContainerStatus($server, 'coolify-proxy_traefik');
+            $server->proxy->set('status', $status);
+            $server->save();
+            if ($status === 'running') {
+                return false;
+            }
+
+            return true;
+        } else {
+            $status = getContainerStatus($server, 'coolify-proxy');
+            if ($status === 'running') {
+                $server->proxy->set('status', 'running');
+                $server->save();
+
+                return false;
+            }
+            if ($server->settings->is_cloudflare_tunnel) {
+                return false;
+            }
+            $ip = $server->ip;
+            if ($server->id === 0) {
+                $ip = 'host.docker.internal';
+            }
+
+            $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 {
+                    $portsToCheck = [];
+                }
+            } catch (\Exception $e) {
+                ray($e->getMessage());
+            }
+            if (count($portsToCheck) === 0) {
+                return false;
+            }
+            foreach ($portsToCheck as $port) {
+                $connection = @fsockopen($ip, $port);
+                if (is_resource($connection) && fclose($connection)) {
+                    if ($fromUI) {
+                        throw new \Exception("Port $port is in use.<br>You must stop the process using this port.<br>Docs: <a target='_blank' href='https://coolify.io/docs'>https://coolify.io/docs</a><br>Discord: <a target='_blank' href='https://coollabs.io/discord'>https://coollabs.io/discord</a>");
+                    } else {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+    }
+}

app/Actions/Proxy/SaveConfiguration.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Actions\Proxy;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class SaveConfiguration
+{
+    use AsAction;
+
+    public function handle(Server $server, ?string $proxy_settings = null)
+    {
+        if (is_null($proxy_settings)) {
+            $proxy_settings = CheckConfiguration::run($server, true);
+        }
+        $proxy_path = $server->proxyPath();
+        $docker_compose_yml_base64 = base64_encode($proxy_settings);
+
+        $server->proxy->last_saved_settings = str($docker_compose_yml_base64)->pipe('md5')->value;
+        $server->save();
+
+        return instant_remote_process([
+            "mkdir -p $proxy_path",
+            "echo '$docker_compose_yml_base64' | base64 -d | tee $proxy_path/docker-compose.yml > /dev/null",
+        ], $server);
+    }
+}

app/Actions/Proxy/StartProxy.php

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

app/Actions/Server/CleanupDocker.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class CleanupDocker
+{
+    use AsAction;
+
+    public function handle(Server $server)
+    {
+        $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

@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Events\CloudflareTunnelConfigured;
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
+
+class ConfigureCloudflared
+{
+    use AsAction;
+
+    public function handle(Server $server, string $cloudflare_token)
+    {
+        try {
+            $config = [
+                'services' => [
+                    'coolify-cloudflared' => [
+                        'container_name' => 'coolify-cloudflared',
+                        'image' => 'cloudflare/cloudflared:latest',
+                        'restart' => RESTART_MODE,
+                        'network_mode' => 'host',
+                        'command' => 'tunnel run',
+                        'environment' => [
+                            "TUNNEL_TOKEN={$cloudflare_token}",
+                        ],
+                    ],
+                ],
+            ];
+            $config = Yaml::dump($config, 12, 2);
+            $docker_compose_yml_base64 = base64_encode($config);
+            $commands = collect([
+                'mkdir -p /tmp/cloudflared',
+                'cd /tmp/cloudflared',
+                "echo '$docker_compose_yml_base64' | base64 -d | tee docker-compose.yml > /dev/null",
+                'docker compose pull',
+                'docker compose down -v --remove-orphans > /dev/null 2>&1',
+                'docker compose up -d --remove-orphans',
+            ]);
+            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/InstallDocker.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use App\Models\StandaloneDocker;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class InstallDocker
+{
+    use AsAction;
+
+    public function handle(Server $server)
+    {
+        $supported_os_type = $server->validateOS();
+        if (! $supported_os_type) {
+            throw new \Exception('Server OS type is not supported for automated installation. Please install Docker manually before continuing: <a target="_blank" class="underline" href="https://coolify.io/docs/installation#manually">documentation</a>.');
+        }
+        ray('Installing Docker on server: '.$server->name.' ('.$server->ip.')'.' with OS type: '.$supported_os_type);
+        $dockerVersion = '24.0';
+        $config = base64_encode('{
+            "log-driver": "json-file",
+            "log-opts": {
+              "max-size": "10m",
+              "max-file": "3"
+            }
+          }');
+        $found = StandaloneDocker::where('server_id', $server->id);
+        if ($found->count() == 0 && $server->id) {
+            StandaloneDocker::create([
+                'name' => 'coolify',
+                'network' => 'coolify',
+                'server_id' => $server->id,
+            ]);
+        }
+        $command = collect([]);
+        if (isDev() && $server->id === 0) {
+            $command = $command->merge([
+                "echo 'Installing Prerequisites...'",
+                'sleep 1',
+                "echo 'Installing Docker Engine...'",
+                "echo 'Configuring Docker Engine (merging existing configuration with the required)...'",
+                'sleep 4',
+                "echo 'Restarting Docker Engine...'",
+                'ls -l /tmp',
+            ]);
+
+            return remote_process($command, $server);
+        } else {
+            if ($supported_os_type->contains('debian')) {
+                $command = $command->merge([
+                    "echo 'Installing Prerequisites...'",
+                    'apt-get update -y',
+                    'command -v curl >/dev/null || apt install -y curl',
+                    'command -v wget >/dev/null || apt install -y wget',
+                    'command -v git >/dev/null || apt install -y git',
+                    'command -v jq >/dev/null || apt install -y jq',
+                ]);
+            } elseif ($supported_os_type->contains('rhel')) {
+                $command = $command->merge([
+                    "echo 'Installing Prerequisites...'",
+                    'command -v curl >/dev/null || dnf install -y curl',
+                    'command -v wget >/dev/null || dnf install -y wget',
+                    'command -v git >/dev/null || dnf install -y git',
+                    'command -v jq >/dev/null || dnf install -y jq',
+                ]);
+            } elseif ($supported_os_type->contains('sles')) {
+                $command = $command->merge([
+                    "echo 'Installing Prerequisites...'",
+                    'zypper update -y',
+                    'command -v curl >/dev/null || zypper install -y curl',
+                    'command -v wget >/dev/null || zypper install -y wget',
+                    'command -v git >/dev/null || zypper install -y git',
+                    'command -v jq >/dev/null || zypper install -y jq',
+                ]);
+            } else {
+                throw new \Exception('Unsupported OS');
+            }
+            $command = $command->merge([
+                "echo 'Installing Docker Engine...'",
+                "curl https://releases.rancher.com/install-docker/{$dockerVersion}.sh | sh || curl https://get.docker.com | sh -s -- --version {$dockerVersion}",
+                "echo 'Configuring Docker Engine (merging existing configuration with the required)...'",
+                'test -s /etc/docker/daemon.json && cp /etc/docker/daemon.json "/etc/docker/daemon.json.original-$(date +"%Y%m%d-%H%M%S")"',
+                "test ! -s /etc/docker/daemon.json && echo '{$config}' | base64 -d | tee /etc/docker/daemon.json > /dev/null",
+                "echo '{$config}' | base64 -d | tee /etc/docker/daemon.json.coolify > /dev/null",
+                'jq . /etc/docker/daemon.json.coolify | tee /etc/docker/daemon.json.coolify.pretty > /dev/null',
+                'mv /etc/docker/daemon.json.coolify.pretty /etc/docker/daemon.json.coolify',
+                "jq -s '.[0] * .[1]' /etc/docker/daemon.json.coolify /etc/docker/daemon.json | tee /etc/docker/daemon.json.appended > /dev/null",
+                'mv /etc/docker/daemon.json.appended /etc/docker/daemon.json',
+                "echo 'Restarting Docker Engine...'",
+                'systemctl enable docker >/dev/null 2>&1 || true',
+                'systemctl restart docker',
+            ]);
+            if ($server->isSwarm()) {
+                $command = $command->merge([
+                    'docker network create --attachable --driver overlay coolify-overlay >/dev/null 2>&1 || true',
+                ]);
+            } else {
+                $command = $command->merge([
+                    'docker network create --attachable coolify >/dev/null 2>&1 || true',
+                ]);
+                $command = $command->merge([
+                    "echo 'Done!'",
+                ]);
+            }
+
+            return remote_process($command, $server);
+        }
+    }
+}

app/Actions/Server/InstallLogDrain.php

@@ -0,0 +1,217 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class InstallLogDrain
+{
+    use AsAction;
+
+    public function handle(Server $server)
+    {
+        if ($server->settings->is_logdrain_newrelic_enabled) {
+            $type = 'newrelic';
+        } elseif ($server->settings->is_logdrain_highlight_enabled) {
+            $type = 'highlight';
+        } elseif ($server->settings->is_logdrain_axiom_enabled) {
+            $type = 'axiom';
+        } elseif ($server->settings->is_logdrain_custom_enabled) {
+            $type = 'custom';
+        } else {
+            $type = 'none';
+        }
+        try {
+            if ($type === 'none') {
+                return 'No log drain is enabled.';
+            } elseif ($type === 'newrelic') {
+                if (! $server->settings->is_logdrain_newrelic_enabled) {
+                    throw new \Exception('New Relic log drain is not enabled.');
+                }
+                $config = base64_encode("
+[SERVICE]
+    Flush     5
+    Daemon    off
+    Tag container_logs
+    Log_Level debug
+    Parsers_File  parsers.conf
+[INPUT]
+    Name              forward
+    Buffer_Chunk_Size 1M
+    Buffer_Max_Size   6M
+[FILTER]
+    Name grep
+    Match *
+    Exclude log 127.0.0.1
+[FILTER]
+    Name                modify
+    Match               *
+    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 *
+    license_key \${LICENSE_KEY}
+    # https://log-api.eu.newrelic.com/log/v1 - EU
+    # https://log-api.newrelic.com/log/v1 - US
+    base_uri \${BASE_URI}
+");
+            } elseif ($type === 'highlight') {
+                if (! $server->settings->is_logdrain_highlight_enabled) {
+                    throw new \Exception('Highlight log drain is not enabled.');
+                }
+                $config = base64_encode('
+[SERVICE]
+    Flush     5
+    Daemon    off
+    Log_Level debug
+    Parsers_File  parsers.conf
+[INPUT]
+    Name              forward
+    tag               ${HIGHLIGHT_PROJECT_ID}
+    Buffer_Chunk_Size 1M
+    Buffer_Max_Size   6M
+[OUTPUT]
+    Name                forward
+    Match               *
+    Host                otel.highlight.io
+    Port                24224
+');
+            } elseif ($type === 'axiom') {
+                if (! $server->settings->is_logdrain_axiom_enabled) {
+                    throw new \Exception('Axiom log drain is not enabled.');
+                }
+                $config = base64_encode("
+[SERVICE]
+    Flush     5
+    Daemon    off
+    Log_Level debug
+    Parsers_File  parsers.conf
+[INPUT]
+    Name              forward
+    Buffer_Chunk_Size 1M
+    Buffer_Max_Size   6M
+[FILTER]
+    Name grep
+    Match *
+    Exclude log 127.0.0.1
+[FILTER]
+    Name                modify
+    Match               *
+    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           *
+    Host            api.axiom.co
+    Port            443
+    URI             /v1/datasets/\${AXIOM_DATASET_NAME}/ingest
+    # Authorization Bearer should be an API token
+    Header Authorization Bearer \${AXIOM_API_KEY}
+    compress gzip
+    format json
+    json_date_key _time
+    json_date_format iso8601
+    tls On
+");
+            } elseif ($type === 'custom') {
+                if (! $server->settings->is_logdrain_custom_enabled) {
+                    throw new \Exception('Custom log drain is not enabled.');
+                }
+                $config = base64_encode($server->settings->logdrain_custom_config);
+                $parsers = base64_encode($server->settings->logdrain_custom_config_parser);
+            } else {
+                throw new \Exception('Unknown log drain type.');
+            }
+            if ($type !== 'custom') {
+                $parsers = base64_encode("
+[PARSER]
+    Name        empty_line_skipper
+    Format      regex
+    Regex       /^(?!\s*$).+/
+");
+            }
+            $compose = base64_encode('
+services:
+  coolify-log-drain:
+    image: cr.fluentbit.io/fluent/fluent-bit:2.0
+    container_name: coolify-log-drain
+    command: -c /fluent-bit.conf
+    env_file:
+      - .env
+    volumes:
+      - ./fluent-bit.conf:/fluent-bit.conf
+      - ./parsers.conf:/parsers.conf
+    ports:
+      - 127.0.0.1:24224:24224
+    restart: unless-stopped
+');
+            $readme = base64_encode('# New Relic Log Drain
+This log drain is based on [Fluent Bit](https://fluentbit.io/) and New Relic Log Forwarder.
+
+Files:
+- `fluent-bit.conf` - configuration file for Fluent Bit
+- `docker-compose.yml` - docker-compose file to run Fluent Bit
+- `.env` - environment variables for Fluent Bit
+');
+            $license_key = $server->settings->logdrain_newrelic_license_key;
+            $base_uri = $server->settings->logdrain_newrelic_base_uri;
+            $base_path = config('coolify.base_config_path');
+
+            $config_path = $base_path.'/log-drains';
+            $fluent_bit_config = $config_path.'/fluent-bit.conf';
+            $parsers_config = $config_path.'/parsers.conf';
+            $compose_path = $config_path.'/docker-compose.yml';
+            $readme_path = $config_path.'/README.md';
+            $command = [
+                "echo 'Saving configuration'",
+                "mkdir -p $config_path",
+                "echo '{$parsers}' | base64 -d | tee $parsers_config > /dev/null",
+                "echo '{$config}' | base64 -d | tee $fluent_bit_config > /dev/null",
+                "echo '{$compose}' | base64 -d | tee $compose_path > /dev/null",
+                "echo '{$readme}' | base64 -d | tee $readme_path > /dev/null",
+                "test -f $config_path/.env && rm $config_path/.env",
+
+            ];
+            if ($type === 'newrelic') {
+                $add_envs_command = [
+                    "echo LICENSE_KEY=$license_key >> $config_path/.env",
+                    "echo BASE_URI=$base_uri >> $config_path/.env",
+                ];
+            } elseif ($type === 'highlight') {
+                $add_envs_command = [
+                    "echo HIGHLIGHT_PROJECT_ID={$server->settings->logdrain_highlight_project_id} >> $config_path/.env",
+                ];
+            } elseif ($type === 'axiom') {
+                $add_envs_command = [
+                    "echo AXIOM_DATASET_NAME={$server->settings->logdrain_axiom_dataset_name} >> $config_path/.env",
+                    "echo AXIOM_API_KEY={$server->settings->logdrain_axiom_api_key} >> $config_path/.env",
+                ];
+            } elseif ($type === 'custom') {
+                $add_envs_command = [
+                    "touch $config_path/.env",
+                ];
+            } else {
+                throw new \Exception('Unknown log drain type.');
+            }
+            $restart_command = [
+                "echo 'Stopping old Fluent Bit'",
+                "cd $config_path && docker compose down --remove-orphans || true",
+                "echo 'Starting Fluent Bit'",
+                "cd $config_path && docker compose up -d --remove-orphans",
+            ];
+            $command = array_merge($command, $add_envs_command, $restart_command);
+
+            return instant_remote_process($command, $server);
+        } catch (\Throwable $e) {
+            return handleError($e);
+        }
+    }
+}

app/Actions/Server/RunCommand.php

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

app/Actions/Server/StartSentinel.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class StartSentinel
+{
+    use AsAction;
+
+    public function handle(Server $server, $version = 'latest', bool $restart = false)
+    {
+        if ($restart) {
+            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 \"TOKEN={$token}\" -e \"SCHEDULER=true\" -e \"METRICS_HISTORY={$metrics_history}\" -e \"REFRESH_RATE={$refresh_rate}\" --name coolify-sentinel -v /var/run/docker.sock:/var/run/docker.sock -v /data/coolify/metrics:/app/metrics -v /data/coolify/logs:/app/logs --pid host --health-cmd \"curl --fail http://127.0.0.1:8888/api/health || exit 1\" --health-interval 10s --health-retries 3 ghcr.io/coollabsio/sentinel:$version",
+            'chown -R 9999:root /data/coolify/metrics /data/coolify/logs',
+            'chmod -R 700 /data/coolify/metrics /data/coolify/logs',
+        ], $server, true);
+    }
+}

app/Actions/Server/StopLogDrain.php

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

app/Actions/Server/StopSentinel.php

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

app/Actions/Server/UpdateCoolify.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Jobs\PullHelperImageJob;
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class UpdateCoolify
+{
+    use AsAction;
+
+    public ?Server $server = null;
+
+    public ?string $latestVersion = null;
+
+    public ?string $currentVersion = null;
+
+    public function handle($manual_update = false)
+    {
+        try {
+            $settings = instanceSettings();
+            $this->server = Server::find(0);
+            if (! $this->server) {
+                return;
+            }
+            CleanupDocker::dispatch($this->server)->onQueue('high');
+            $this->latestVersion = get_latest_version_of_coolify();
+            $this->currentVersion = config('version');
+            if (! $manual_update) {
+                if (! $settings->is_auto_update_enabled) {
+                    return;
+                }
+                if ($this->latestVersion === $this->currentVersion) {
+                    return;
+                }
+                if (version_compare($this->latestVersion, $this->currentVersion, '<')) {
+                    return;
+                }
+            }
+            $this->update();
+            $settings->new_version_available = false;
+            $settings->save();
+        } catch (\Throwable $e) {
+            throw $e;
+        }
+    }
+
+    private function update()
+    {
+        if (isDev()) {
+            remote_process([
+                'sleep 10',
+            ], $this->server);
+
+            return;
+        }
+
+        $all_servers = Server::all();
+        $servers = $all_servers->where('settings.is_usable', true)->where('settings.is_reachable', true)->where('ip', '!=', '1.2.3.4');
+        foreach ($servers as $server) {
+            PullHelperImageJob::dispatch($server);
+        }
+
+        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

@@ -0,0 +1,77 @@
+<?php
+
+namespace App\Actions\Service;
+
+use App\Actions\Server\CleanupDocker;
+use App\Models\Service;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class DeleteService
+{
+    use AsAction;
+
+    public function handle(Service $service, bool $deleteConfigurations, bool $deleteVolumes, bool $dockerCleanup, bool $deleteConnectedNetworks)
+    {
+        try {
+            $server = data_get($service, 'server');
+            if ($deleteVolumes && $server->isFunctional()) {
+                $storagesToDelete = collect([]);
+
+                $service->environment_variables()->delete();
+                $commands = [];
+                foreach ($service->applications()->get() as $application) {
+                    $storages = $application->persistentStorages()->get();
+                    foreach ($storages as $storage) {
+                        $storagesToDelete->push($storage);
+                    }
+                }
+                foreach ($service->databases()->get() as $database) {
+                    $storages = $database->persistentStorages()->get();
+                    foreach ($storages as $storage) {
+                        $storagesToDelete->push($storage);
+                    }
+                }
+                foreach ($storagesToDelete as $storage) {
+                    $commands[] = "docker volume rm -f $storage->name";
+                }
+
+                // 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();
+            }
+            foreach ($service->databases()->get() as $database) {
+                $database->forceDelete();
+            }
+            foreach ($service->scheduled_tasks as $task) {
+                $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

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

app/Actions/Service/StopService.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Actions\Service;
+
+use App\Actions\Server\CleanupDocker;
+use App\Models\Service;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class StopService
+{
+    use AsAction;
+
+    public function handle(Service $service, bool $isDeleteOperation = false, bool $dockerCleanup = true)
+    {
+        try {
+            $server = $service->destination->server;
+            if (! $server->isFunctional()) {
+                return 'Server is not functional';
+            }
+
+            $containersToStop = $service->getContainersToStop();
+            $service->stopContainers($containersToStop, $server);
+
+            if (! $isDeleteOperation) {
+                $service->delete_connected_networks($service->uuid);
+                if ($dockerCleanup) {
+                    CleanupDocker::dispatch($server, true);
+                }
+            }
+        } catch (\Exception $e) {
+            ray($e->getMessage());
+
+            return $e->getMessage();
+        }
+    }
+}

app/Actions/Shared/ComplexStatusCheck.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Actions\Shared;
+
+use App\Models\Application;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class ComplexStatusCheck
+{
+    use AsAction;
+
+    public function handle(Application $application)
+    {
+        $servers = $application->additional_servers;
+        $servers->push($application->destination->server);
+        foreach ($servers as $server) {
+            $is_main_server = $application->destination->server->id === $server->id;
+            if (! $server->isFunctional()) {
+                if ($is_main_server) {
+                    $application->update(['status' => 'exited:unhealthy']);
+
+                    continue;
+                } else {
+                    $application->additional_servers()->updateExistingPivot($server->id, ['status' => 'exited:unhealthy']);
+
+                    continue;
+                }
+            }
+            $container = instant_remote_process(["docker container inspect $(docker container ls -q --filter 'label=coolify.applicationId={$application->id}' --filter 'label=coolify.pullRequestId=0') --format '{{json .}}'"], $server, false);
+            $container = format_docker_command_output_to_json($container);
+            if ($container->count() === 1) {
+                $container = $container->first();
+                $containerStatus = data_get($container, 'State.Status');
+                $containerHealth = data_get($container, 'State.Health.Status', 'unhealthy');
+                if ($is_main_server) {
+                    $statusFromDb = $application->status;
+                    if ($statusFromDb !== $containerStatus) {
+                        $application->update(['status' => "$containerStatus:$containerHealth"]);
+                    }
+                } else {
+                    $additional_server = $application->additional_servers()->wherePivot('server_id', $server->id);
+                    $statusFromDb = $additional_server->first()->pivot->status;
+                    if ($statusFromDb !== $containerStatus) {
+                        $additional_server->updateExistingPivot($server->id, ['status' => "$containerStatus:$containerHealth"]);
+                    }
+                }
+            } else {
+                if ($is_main_server) {
+                    $application->update(['status' => 'exited:unhealthy']);
+
+                    continue;
+                } else {
+                    $application->additional_servers()->updateExistingPivot($server->id, ['status' => 'exited:unhealthy']);
+
+                    continue;
+                }
+            }
+        }
+    }
+}

app/Actions/Shared/PullImage.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Actions\Shared;
+
+use App\Models\Service;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class PullImage
+{
+    use AsAction;
+
+    public function handle(Service $resource)
+    {
+        $resource->saveComposeConfigs();
+
+        $commands[] = 'cd '.$resource->workdir();
+        $commands[] = "echo 'Saved configuration files to {$resource->workdir()}.'";
+        $commands[] = 'docker compose pull';
+
+        $server = data_get($resource, 'server');
+
+        if (! $server) {
+            return;
+        }
+
+        instant_remote_process($commands, $resource->server);
+    }
+}

app/Console/Commands/AdminRemoveUser.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\User;
+use Illuminate\Console\Command;
+
+class AdminRemoveUser extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'admin:remove-user {email}';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Remove User from database';
+
+    /**
+     * Execute the console command.
+     */
+    public function handle()
+    {
+        try {
+            $email = $this->argument('email');
+            $confirm = $this->confirm('Are you sure you want to remove user with email: '.$email.'?');
+            if (! $confirm) {
+                $this->info('User removal cancelled.');
+
+                return;
+            }
+            $this->info("Removing user with email: $email");
+            $user = User::whereEmail($email)->firstOrFail();
+            $teams = $user->teams;
+            foreach ($teams as $team) {
+                if ($team->members->count() > 1) {
+                    $this->error('User is a member of a team with more than one member. Please remove user from team first.');
+
+                    return;
+                }
+                $team->delete();
+            }
+            $user->delete();
+        } catch (\Exception $e) {
+            $this->error('Failed to remove user.');
+            $this->error($e->getMessage());
+
+            return;
+        }
+    }
+}

app/Console/Commands/CheckApplicationDeploymentQueue.php

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

app/Console/Commands/CleanupApplicationDeploymentQueue.php

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

app/Console/Commands/CleanupDatabase.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace App\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\DB;
+
+class CleanupDatabase extends Command
+{
+    protected $signature = 'cleanup:database {--yes}';
+
+    protected $description = 'Cleanup database';
+
+    public function handle()
+    {
+        if ($this->option('yes')) {
+            echo "Running database cleanup...\n";
+        } else {
+            echo "Running database cleanup in dry-run mode...\n";
+        }
+        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));
+        $count = $failed_jobs->count();
+        echo "Delete $count entries from failed_jobs.\n";
+        if ($this->option('yes')) {
+            $failed_jobs->delete();
+        }
+
+        // Cleanup sessions table
+        $sessions = DB::table('sessions')->where('last_activity', '<', now()->subDays($keep_days)->timestamp);
+        $count = $sessions->count();
+        echo "Delete $count entries from sessions.\n";
+        if ($this->option('yes')) {
+            $sessions->delete();
+        }
+
+        // Cleanup activity_log table
+        $activity_log = DB::table('activity_log')->where('created_at', '<', now()->subDays($keep_days))->orderBy('created_at', 'desc')->skip(10);
+        $count = $activity_log->count();
+        echo "Delete $count entries from activity_log.\n";
+        if ($this->option('yes')) {
+            $activity_log->delete();
+        }
+
+        // Cleanup application_deployment_queues table
+        $application_deployment_queues = DB::table('application_deployment_queues')->where('created_at', '<', now()->subDays($keep_days))->orderBy('created_at', 'desc')->skip(10);
+        $count = $application_deployment_queues->count();
+        echo "Delete $count entries from application_deployment_queues.\n";
+        if ($this->option('yes')) {
+            $application_deployment_queues->delete();
+        }
+
+        // Cleanup webhooks table
+        $webhooks = DB::table('webhooks')->where('created_at', '<', now()->subDays($keep_days));
+        $count = $webhooks->count();
+        echo "Delete $count entries from webhooks.\n";
+        if ($this->option('yes')) {
+            $webhooks->delete();
+        }
+
+    }
+}

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

@@ -0,0 +1,412 @@
+<?php
+
+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;
+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 Illuminate\Console\Command;
+
+class CleanupStuckedResources extends Command
+{
+    protected $signature = 'cleanup:stucked-resources';
+
+    protected $description = 'Cleanup Stucked Resources';
+
+    public function handle()
+    {
+        ray('Running cleanup stucked resources.');
+        echo "Running cleanup stucked resources.\n";
+        $this->cleanup_stucked_resources();
+    }
+
+    private function cleanup_stucked_resources()
+    {
+
+        try {
+            $servers = Server::all()->filter(function ($server) {
+                return $server->isFunctional();
+            });
+            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) {
+                echo "Deleting stuck application: {$application->name}\n";
+                $application->forceDelete();
+            }
+        } 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) {
+                echo "Deleting stuck postgresql: {$postgresql->name}\n";
+                $postgresql->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck postgresql: {$e->getMessage()}\n";
+        }
+        try {
+            $redis = StandaloneRedis::withTrashed()->whereNotNull('deleted_at')->get();
+            foreach ($redis as $redis) {
+                echo "Deleting stuck redis: {$redis->name}\n";
+                $redis->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck redis: {$e->getMessage()}\n";
+        }
+        try {
+            $keydbs = StandaloneKeydb::withTrashed()->whereNotNull('deleted_at')->get();
+            foreach ($keydbs as $keydb) {
+                echo "Deleting stuck keydb: {$keydb->name}\n";
+                $keydb->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck keydb: {$e->getMessage()}\n";
+        }
+        try {
+            $dragonflies = StandaloneDragonfly::withTrashed()->whereNotNull('deleted_at')->get();
+            foreach ($dragonflies as $dragonfly) {
+                echo "Deleting stuck dragonfly: {$dragonfly->name}\n";
+                $dragonfly->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck dragonfly: {$e->getMessage()}\n";
+        }
+        try {
+            $clickhouses = StandaloneClickhouse::withTrashed()->whereNotNull('deleted_at')->get();
+            foreach ($clickhouses as $clickhouse) {
+                echo "Deleting stuck clickhouse: {$clickhouse->name}\n";
+                $clickhouse->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck clickhouse: {$e->getMessage()}\n";
+        }
+        try {
+            $mongodbs = StandaloneMongodb::withTrashed()->whereNotNull('deleted_at')->get();
+            foreach ($mongodbs as $mongodb) {
+                echo "Deleting stuck mongodb: {$mongodb->name}\n";
+                $mongodb->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck mongodb: {$e->getMessage()}\n";
+        }
+        try {
+            $mysqls = StandaloneMysql::withTrashed()->whereNotNull('deleted_at')->get();
+            foreach ($mysqls as $mysql) {
+                echo "Deleting stuck mysql: {$mysql->name}\n";
+                $mysql->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck mysql: {$e->getMessage()}\n";
+        }
+        try {
+            $mariadbs = StandaloneMariadb::withTrashed()->whereNotNull('deleted_at')->get();
+            foreach ($mariadbs as $mariadb) {
+                echo "Deleting stuck mariadb: {$mariadb->name}\n";
+                $mariadb->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck mariadb: {$e->getMessage()}\n";
+        }
+        try {
+            $services = Service::withTrashed()->whereNotNull('deleted_at')->get();
+            foreach ($services as $service) {
+                echo "Deleting stuck service: {$service->name}\n";
+                $service->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck service: {$e->getMessage()}\n";
+        }
+        try {
+            $serviceApps = ServiceApplication::withTrashed()->whereNotNull('deleted_at')->get();
+            foreach ($serviceApps as $serviceApp) {
+                echo "Deleting stuck serviceapp: {$serviceApp->name}\n";
+                $serviceApp->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck serviceapp: {$e->getMessage()}\n";
+        }
+        try {
+            $serviceDbs = ServiceDatabase::withTrashed()->whereNotNull('deleted_at')->get();
+            foreach ($serviceDbs as $serviceDb) {
+                echo "Deleting stuck serviceapp: {$serviceDb->name}\n";
+                $serviceDb->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck serviceapp: {$e->getMessage()}\n";
+        }
+        try {
+            $scheduled_tasks = ScheduledTask::all();
+            foreach ($scheduled_tasks as $scheduled_task) {
+                if (! $scheduled_task->service && ! $scheduled_task->application) {
+                    echo "Deleting stuck scheduledtask: {$scheduled_task->name}\n";
+                    $scheduled_task->delete();
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck scheduledtasks: {$e->getMessage()}\n";
+        }
+
+        try {
+            $scheduled_backups = ScheduledDatabaseBackup::all();
+            foreach ($scheduled_backups as $scheduled_backup) {
+                if (! $scheduled_backup->server()) {
+                    echo "Deleting stuck scheduledbackup: {$scheduled_backup->name}\n";
+                    $scheduled_backup->delete();
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck scheduledbackups: {$e->getMessage()}\n";
+        }
+
+        // Cleanup any resources that are not attached to any environment or destination or server
+        try {
+            $applications = Application::all();
+            foreach ($applications as $application) {
+                if (! data_get($application, 'environment')) {
+                    echo 'Application without environment: '.$application->name.'\n';
+                    $application->forceDelete();
+
+                    continue;
+                }
+                if (! $application->destination()) {
+                    echo 'Application without destination: '.$application->name.'\n';
+                    $application->forceDelete();
+
+                    continue;
+                }
+                if (! data_get($application, 'destination.server')) {
+                    echo 'Application without server: '.$application->name.'\n';
+                    $application->forceDelete();
+
+                    continue;
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in application: {$e->getMessage()}\n";
+        }
+        try {
+            $postgresqls = StandalonePostgresql::all()->where('id', '!=', 0);
+            foreach ($postgresqls as $postgresql) {
+                if (! data_get($postgresql, 'environment')) {
+                    echo 'Postgresql without environment: '.$postgresql->name.'\n';
+                    $postgresql->forceDelete();
+
+                    continue;
+                }
+                if (! $postgresql->destination()) {
+                    echo 'Postgresql without destination: '.$postgresql->name.'\n';
+                    $postgresql->forceDelete();
+
+                    continue;
+                }
+                if (! data_get($postgresql, 'destination.server')) {
+                    echo 'Postgresql without server: '.$postgresql->name.'\n';
+                    $postgresql->forceDelete();
+
+                    continue;
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in postgresql: {$e->getMessage()}\n";
+        }
+        try {
+            $redis = StandaloneRedis::all();
+            foreach ($redis as $redis) {
+                if (! data_get($redis, 'environment')) {
+                    echo 'Redis without environment: '.$redis->name.'\n';
+                    $redis->forceDelete();
+
+                    continue;
+                }
+                if (! $redis->destination()) {
+                    echo 'Redis without destination: '.$redis->name.'\n';
+                    $redis->forceDelete();
+
+                    continue;
+                }
+                if (! data_get($redis, 'destination.server')) {
+                    echo 'Redis without server: '.$redis->name.'\n';
+                    $redis->forceDelete();
+
+                    continue;
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in redis: {$e->getMessage()}\n";
+        }
+
+        try {
+            $mongodbs = StandaloneMongodb::all();
+            foreach ($mongodbs as $mongodb) {
+                if (! data_get($mongodb, 'environment')) {
+                    echo 'Mongodb without environment: '.$mongodb->name.'\n';
+                    $mongodb->forceDelete();
+
+                    continue;
+                }
+                if (! $mongodb->destination()) {
+                    echo 'Mongodb without destination: '.$mongodb->name.'\n';
+                    $mongodb->forceDelete();
+
+                    continue;
+                }
+                if (! data_get($mongodb, 'destination.server')) {
+                    echo 'Mongodb without server:  '.$mongodb->name.'\n';
+                    $mongodb->forceDelete();
+
+                    continue;
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in mongodb: {$e->getMessage()}\n";
+        }
+
+        try {
+            $mysqls = StandaloneMysql::all();
+            foreach ($mysqls as $mysql) {
+                if (! data_get($mysql, 'environment')) {
+                    echo 'Mysql without environment: '.$mysql->name.'\n';
+                    $mysql->forceDelete();
+
+                    continue;
+                }
+                if (! $mysql->destination()) {
+                    echo 'Mysql without destination: '.$mysql->name.'\n';
+                    $mysql->forceDelete();
+
+                    continue;
+                }
+                if (! data_get($mysql, 'destination.server')) {
+                    echo 'Mysql without server: '.$mysql->name.'\n';
+                    $mysql->forceDelete();
+
+                    continue;
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in mysql: {$e->getMessage()}\n";
+        }
+
+        try {
+            $mariadbs = StandaloneMariadb::all();
+            foreach ($mariadbs as $mariadb) {
+                if (! data_get($mariadb, 'environment')) {
+                    echo 'Mariadb without environment: '.$mariadb->name.'\n';
+                    $mariadb->forceDelete();
+
+                    continue;
+                }
+                if (! $mariadb->destination()) {
+                    echo 'Mariadb without destination: '.$mariadb->name.'\n';
+                    $mariadb->forceDelete();
+
+                    continue;
+                }
+                if (! data_get($mariadb, 'destination.server')) {
+                    echo 'Mariadb without server: '.$mariadb->name.'\n';
+                    $mariadb->forceDelete();
+
+                    continue;
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in mariadb: {$e->getMessage()}\n";
+        }
+
+        try {
+            $services = Service::all();
+            foreach ($services as $service) {
+                if (! data_get($service, 'environment')) {
+                    echo 'Service without environment: '.$service->name.'\n';
+                    $service->forceDelete();
+
+                    continue;
+                }
+                if (! $service->destination()) {
+                    echo 'Service without destination: '.$service->name.'\n';
+                    $service->forceDelete();
+
+                    continue;
+                }
+                if (! data_get($service, 'server')) {
+                    echo 'Service without server: '.$service->name.'\n';
+                    $service->forceDelete();
+
+                    continue;
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in service: {$e->getMessage()}\n";
+        }
+        try {
+            $serviceApplications = ServiceApplication::all();
+            foreach ($serviceApplications as $service) {
+                if (! data_get($service, 'service')) {
+                    echo 'ServiceApplication without service: '.$service->name.'\n';
+                    $service->forceDelete();
+
+                    continue;
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in serviceApplications: {$e->getMessage()}\n";
+        }
+        try {
+            $serviceDatabases = ServiceDatabase::all();
+            foreach ($serviceDatabases as $service) {
+                if (! data_get($service, 'service')) {
+                    echo 'ServiceDatabase without service: '.$service->name.'\n';
+                    $service->forceDelete();
+
+                    continue;
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in ServiceDatabases: {$e->getMessage()}\n";
+        }
+    }
+}

app/Console/Commands/CleanupUnreachableServers.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Server;
+use Illuminate\Console\Command;
+
+class CleanupUnreachableServers extends Command
+{
+    protected $signature = 'cleanup:unreachable-servers';
+
+    protected $description = 'Cleanup Unreachable Servers (7 days)';
+
+    public function handle()
+    {
+        echo "Running unreachable server cleanup...\n";
+        $servers = Server::where('unreachable_count', 3)->where('unreachable_notification_sent', true)->where('updated_at', '<', now()->subDays(7))->get();
+        if ($servers->count() > 0) {
+            foreach ($servers as $server) {
+                echo "Cleanup unreachable server ($server->id) with name $server->name";
+                // send_internal_notification("Server $server->name is unreachable for 7 days. Cleaning up...");
+                $server->update([
+                    'ip' => '1.2.3.4',
+                ]);
+            }
+        }
+    }
+}

app/Console/Commands/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

@@ -0,0 +1,69 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\InstanceSettings;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Artisan;
+use Illuminate\Support\Facades\Process;
+
+class Dev extends Command
+{
+    protected $signature = 'dev {--init} {--generate-openapi}';
+
+    protected $description = 'Helper commands for development.';
+
+    public function handle()
+    {
+        if ($this->option('init')) {
+            $this->init();
+
+            return;
+        }
+        if ($this->option('generate-openapi')) {
+            $this->generateOpenApi();
+
+            return;
+        }
+
+    }
+
+    public function generateOpenApi()
+    {
+        // Generate OpenAPI documentation
+        echo "Generating OpenAPI documentation.\n";
+        $process = Process::run(['/var/www/html/vendor/bin/openapi', 'app', '-o', 'openapi.yaml']);
+        $error = $process->errorOutput();
+        $error = preg_replace('/^.*an object literal,.*$/m', '', $error);
+        $error = preg_replace('/^\h*\v+/m', '', $error);
+        echo $error;
+        echo $process->output();
+    }
+
+    public function init()
+    {
+        // Generate APP_KEY if not exists
+
+        if (empty(env('APP_KEY'))) {
+            echo "Generating APP_KEY.\n";
+            Artisan::call('key:generate');
+        }
+
+        // Generate STORAGE link if not exists
+        if (! file_exists(public_path('storage'))) {
+            echo "Generating STORAGE link.\n";
+            Artisan::call('storage:link');
+        }
+
+        // Seed database if it's empty
+        $settings = InstanceSettings::find(0);
+        if (! $settings) {
+            echo "Initializing instance, seeding database.\n";
+            Artisan::call('migrate --seed');
+        } else {
+            echo "Instance already initialized.\n";
+        }
+        // Set permissions
+        Process::run(['chmod', '-R', 'o+rwx', '.']);
+    }
+}

app/Console/Commands/Emails.php

@@ -0,0 +1,317 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Jobs\SendConfirmationForWaitlistJob;
+use App\Models\Application;
+use App\Models\ApplicationPreview;
+use App\Models\ScheduledDatabaseBackup;
+use App\Models\Server;
+use App\Models\StandalonePostgresql;
+use App\Models\Team;
+use App\Models\Waitlist;
+use App\Notifications\Application\DeploymentFailed;
+use App\Notifications\Application\DeploymentSuccess;
+use App\Notifications\Application\StatusChanged;
+use App\Notifications\Database\BackupFailed;
+use App\Notifications\Database\BackupSuccess;
+use App\Notifications\Database\DailyBackup;
+use App\Notifications\Test;
+use Exception;
+use Illuminate\Console\Command;
+use Illuminate\Mail\Message;
+use Illuminate\Notifications\Messages\MailMessage;
+use Mail;
+
+use function Laravel\Prompts\confirm;
+use function Laravel\Prompts\select;
+use function Laravel\Prompts\text;
+
+class Emails extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'emails';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Send out test / prod emails';
+
+    /**
+     * Execute the console command.
+     */
+    private ?MailMessage $mail = null;
+
+    private ?string $email = null;
+
+    public function handle()
+    {
+        $type = select(
+            'Which Email should be sent?',
+            options: [
+                'updates' => 'Send Update Email to all users',
+                'emails-test' => 'Test',
+                'database-backup-statuses-daily' => 'Database - Backup Statuses (Daily)',
+                'application-deployment-success-daily' => 'Application - Deployment Success (Daily)',
+                'application-deployment-success' => 'Application - Deployment Success',
+                'application-deployment-failed' => 'Application - Deployment Failed',
+                'application-status-changed' => 'Application - Status Changed',
+                'backup-success' => 'Database - Backup Success',
+                'backup-failed' => 'Database - Backup Failed',
+                // 'invitation-link' => 'Invitation Link',
+                'waitlist-invitation-link' => 'Waitlist Invitation Link',
+                'waitlist-confirmation' => 'Waitlist Confirmation',
+                'realusers-before-trial' => 'REAL - Registered Users Before Trial without Subscription',
+                'realusers-server-lost-connection' => 'REAL - Server Lost Connection',
+            ],
+        );
+        $emailsGathered = ['realusers-before-trial', 'realusers-server-lost-connection'];
+        if (isDev()) {
+            $this->email = 'test@example.com';
+        } else {
+            if (! in_array($type, $emailsGathered)) {
+                $this->email = text('Email Address to send to:');
+            }
+        }
+        set_transanctional_email_settings();
+
+        $this->mail = new MailMessage;
+        $this->mail->subject('Test Email');
+        switch ($type) {
+            case 'updates':
+                $teams = Team::all();
+                if (! $teams || $teams->isEmpty()) {
+                    echo 'No teams found.'.PHP_EOL;
+
+                    return;
+                }
+                $emails = [];
+                foreach ($teams as $team) {
+                    foreach ($team->members as $member) {
+                        if ($member->email && $member->marketing_emails) {
+                            $emails[] = $member->email;
+                        }
+                    }
+                }
+                $emails = array_unique($emails);
+                $this->info('Sending to '.count($emails).' emails.');
+                foreach ($emails as $email) {
+                    $this->info($email);
+                }
+                $confirmed = confirm('Are you sure?');
+                if ($confirmed) {
+                    foreach ($emails as $email) {
+                        $this->mail = new MailMessage;
+                        $this->mail->subject('One-click Services, Docker Compose support');
+                        $unsubscribeUrl = route('unsubscribe.marketing.emails', [
+                            'token' => encrypt($email),
+                        ]);
+                        $this->mail->view('emails.updates', ['unsubscribeUrl' => $unsubscribeUrl]);
+                        $this->sendEmail($email);
+                    }
+                }
+                break;
+            case 'emails-test':
+                $this->mail = (new Test)->toMail();
+                $this->sendEmail();
+                break;
+            case 'database-backup-statuses-daily':
+                $scheduled_backups = ScheduledDatabaseBackup::all();
+                $databases = collect();
+                foreach ($scheduled_backups as $scheduled_backup) {
+                    $last_days_backups = $scheduled_backup->get_last_days_backup_status();
+                    if ($last_days_backups->isEmpty()) {
+                        continue;
+                    }
+                    $failed = $last_days_backups->where('status', 'failed');
+                    $database = $scheduled_backup->database;
+                    $databases->put($database->name, [
+                        'failed_count' => $failed->count(),
+                    ]);
+                }
+                $this->mail = (new DailyBackup($databases))->toMail();
+                $this->sendEmail();
+                break;
+            case 'application-deployment-success-daily':
+                $applications = Application::all();
+                foreach ($applications as $application) {
+                    $deployments = $application->get_last_days_deployments();
+                    ray($deployments);
+                    if ($deployments->isEmpty()) {
+                        continue;
+                    }
+                    $this->mail = (new DeploymentSuccess($application, 'test'))->toMail();
+                    $this->sendEmail();
+                }
+                break;
+            case 'application-deployment-success':
+                $application = Application::all()->first();
+                $this->mail = (new DeploymentSuccess($application, 'test'))->toMail();
+                $this->sendEmail();
+                break;
+            case 'application-deployment-failed':
+                $application = Application::all()->first();
+                $preview = ApplicationPreview::all()->first();
+                if (! $preview) {
+                    $preview = ApplicationPreview::create([
+                        'application_id' => $application->id,
+                        'pull_request_id' => 1,
+                        'pull_request_html_url' => 'http://example.com',
+                        'fqdn' => $application->fqdn,
+                    ]);
+                }
+                $this->mail = (new DeploymentFailed($application, 'test'))->toMail();
+                $this->sendEmail();
+                $this->mail = (new DeploymentFailed($application, 'test', $preview))->toMail();
+                $this->sendEmail();
+                break;
+            case 'application-status-changed':
+                $application = Application::all()->first();
+                $this->mail = (new StatusChanged($application))->toMail();
+                $this->sendEmail();
+                break;
+            case 'backup-failed':
+                $backup = ScheduledDatabaseBackup::all()->first();
+                $db = StandalonePostgresql::all()->first();
+                if (! $backup) {
+                    $backup = ScheduledDatabaseBackup::create([
+                        'enabled' => true,
+                        'frequency' => 'daily',
+                        'save_s3' => false,
+                        'database_id' => $db->id,
+                        'database_type' => $db->getMorphClass(),
+                        'team_id' => 0,
+                    ]);
+                }
+                $output = 'Because of an error, the backup of the database '.$db->name.' failed.';
+                $this->mail = (new BackupFailed($backup, $db, $output))->toMail();
+                $this->sendEmail();
+                break;
+            case 'backup-success':
+                $backup = ScheduledDatabaseBackup::all()->first();
+                $db = StandalonePostgresql::all()->first();
+                if (! $backup) {
+                    $backup = ScheduledDatabaseBackup::create([
+                        'enabled' => true,
+                        'frequency' => 'daily',
+                        'save_s3' => false,
+                        'database_id' => $db->id,
+                        'database_type' => $db->getMorphClass(),
+                        'team_id' => 0,
+                    ]);
+                }
+                $this->mail = (new BackupSuccess($backup, $db))->toMail();
+                $this->sendEmail();
+                break;
+                // case 'invitation-link':
+                //     $user = User::all()->first();
+                //     $invitation = TeamInvitation::whereEmail($user->email)->first();
+                //     if (!$invitation) {
+                //         $invitation = TeamInvitation::create([
+                //             'uuid' => Str::uuid(),
+                //             'email' => $user->email,
+                //             'team_id' => 1,
+                //             'link' => 'http://example.com',
+                //         ]);
+                //     }
+                //     $this->mail = (new InvitationLink($user))->toMail();
+                //     $this->sendEmail();
+                //     break;
+            case 'waitlist-invitation-link':
+                $this->mail = new MailMessage;
+                $this->mail->view('emails.waitlist-invitation', [
+                    'loginLink' => 'https://coolify.io',
+                ]);
+                $this->mail->subject('Congratulations! You are invited to join Coolify Cloud.');
+                $this->sendEmail();
+                break;
+            case 'waitlist-confirmation':
+                $found = Waitlist::where('email', $this->email)->first();
+                if ($found) {
+                    SendConfirmationForWaitlistJob::dispatch($this->email, $found->uuid);
+                } else {
+                    throw new Exception('Waitlist not found');
+                }
+
+                break;
+            case 'realusers-before-trial':
+                $this->mail = new MailMessage;
+                $this->mail->view('emails.before-trial-conversion');
+                $this->mail->subject('Trial period has been added for all subscription plans.');
+                $teams = Team::doesntHave('subscription')->where('id', '!=', 0)->get();
+                if (! $teams || $teams->isEmpty()) {
+                    echo 'No teams found.'.PHP_EOL;
+
+                    return;
+                }
+                $emails = [];
+                foreach ($teams as $team) {
+                    foreach ($team->members as $member) {
+                        if ($member->email) {
+                            $emails[] = $member->email;
+                        }
+                    }
+                }
+                $emails = array_unique($emails);
+                $this->info('Sending to '.count($emails).' emails.');
+                foreach ($emails as $email) {
+                    $this->info($email);
+                }
+                $confirmed = confirm('Are you sure?');
+                if ($confirmed) {
+                    foreach ($emails as $email) {
+                        $this->sendEmail($email);
+                    }
+                }
+                break;
+            case 'realusers-server-lost-connection':
+                $serverId = text('Server Id');
+                $server = Server::find($serverId);
+                if (! $server) {
+                    throw new Exception('Server not found');
+                }
+                $admins = [];
+                $members = $server->team->members;
+                foreach ($members as $member) {
+                    if ($member->isAdmin()) {
+                        $admins[] = $member->email;
+                    }
+                }
+                $this->info('Sending to '.count($admins).' admins.');
+                foreach ($admins as $admin) {
+                    $this->info($admin);
+                }
+                $this->mail = new MailMessage;
+                $this->mail->view('emails.server-lost-connection', [
+                    'name' => $server->name,
+                ]);
+                $this->mail->subject('Action required: Server '.$server->name.' lost connection.');
+                foreach ($admins as $email) {
+                    $this->sendEmail($email);
+                }
+                break;
+        }
+    }
+
+    private function sendEmail(?string $email = null)
+    {
+        if ($email) {
+            $this->email = $email;
+        }
+        Mail::send(
+            [],
+            [],
+            fn (Message $message) => $message
+                ->to($this->email)
+                ->subject($this->mail->subject)
+                ->html((string) $this->mail->render())
+        );
+        $this->info("Email sent to $this->email successfully. 📧");
+    }
+}

app/Console/Commands/Horizon.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Console\Commands;
+
+use Illuminate\Console\Command;
+
+class Horizon extends Command
+{
+    protected $signature = 'start:horizon';
+
+    protected $description = 'Start Horizon';
+
+    public function handle()
+    {
+        if (config('coolify.is_horizon_enabled')) {
+            $this->info('Horizon is enabled. Starting.');
+            $this->call('horizon');
+            exit(0);
+        } else {
+            exit(0);
+        }
+    }
+}

app/Console/Commands/Init.php

@@ -0,0 +1,244 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Actions\Server\StopSentinel;
+use App\Enums\ActivityTypes;
+use App\Enums\ApplicationDeploymentStatus;
+use App\Models\ApplicationDeploymentQueue;
+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 {--force-cloud}';
+
+    protected $description = 'Cleanup instance related stuffs';
+
+    public $servers = null;
+
+    public function handle()
+    {
+        if (isCloud() && ! $this->option('force-cloud')) {
+            echo "Skipping init as we are on cloud and --force-cloud option is not set\n";
+
+            return;
+        }
+
+        $this->servers = Server::all();
+        if (isCloud()) {
+
+        } else {
+            $this->send_alive_signal();
+            get_public_ips();
+        }
+
+        // Backward compatibility
+        $this->disable_metrics();
+        $this->replace_slash_in_environment_name();
+        $this->restore_coolify_db_backup();
+        //
+        $this->update_traefik_labels();
+        if (! isCloud() || $this->option('force-cloud')) {
+            $this->cleanup_unused_network_from_coolify_proxy();
+        }
+        if (isCloud()) {
+            $this->cleanup_unnecessary_dynamic_proxy_configuration();
+        } else {
+            $this->cleanup_in_progress_application_deployments();
+        }
+        $this->call('cleanup:redis');
+        $this->call('cleanup:stucked-resources');
+
+        if (isCloud()) {
+            $response = Http::retry(3, 1000)->get(config('constants.services.official'));
+            if ($response->successful()) {
+                $services = $response->json();
+                File::put(base_path('templates/service-templates.json'), json_encode($services));
+            }
+        } else {
+            try {
+                $localhost = $this->servers->where('id', 0)->first();
+                $localhost->setupDynamicProxyConfiguration();
+            } catch (\Throwable $e) {
+                echo "Could not setup dynamic configuration: {$e->getMessage()}\n";
+            }
+            $settings = instanceSettings();
+            if (! is_null(env('AUTOUPDATE', null))) {
+                if (env('AUTOUPDATE') == true) {
+                    $settings->update(['is_auto_update_enabled' => true]);
+                } else {
+                    $settings->update(['is_auto_update_enabled' => false]);
+                }
+            }
+        }
+    }
+
+    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()
+    {
+        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 send_alive_signal()
+    {
+        $id = config('app.id');
+        $version = config('version');
+        $settings = instanceSettings();
+        $do_not_track = data_get($settings, 'do_not_track');
+        if ($do_not_track == true) {
+            echo "Skipping alive as do_not_track is enabled\n";
+
+            return;
+        }
+        try {
+            Http::get("https://undead.coolify.io/v4/alive?appId=$id&version=$version");
+            echo "I am alive!\n";
+        } catch (\Throwable $e) {
+            echo "Error in alive: {$e->getMessage()}\n";
+        }
+    }
+
+    private function cleanup_in_progress_application_deployments()
+    {
+        // Cleanup any failed deployments
+        try {
+            if (isCloud()) {
+                return;
+            }
+            $queued_inprogress_deployments = ApplicationDeploymentQueue::whereIn('status', [ApplicationDeploymentStatus::IN_PROGRESS->value, ApplicationDeploymentStatus::QUEUED->value])->get();
+            foreach ($queued_inprogress_deployments as $deployment) {
+                ray($deployment->id, $deployment->status);
+                echo "Cleaning up deployment: {$deployment->id}\n";
+                $deployment->status = ApplicationDeploymentStatus::FAILED->value;
+                $deployment->save();
+            }
+        } catch (\Throwable $e) {
+            echo "Error: {$e->getMessage()}\n";
+        }
+    }
+
+    private function replace_slash_in_environment_name()
+    {
+        if (version_compare('4.0.0-beta.298', config('version'), '<=')) {
+            $environments = Environment::all();
+            foreach ($environments as $environment) {
+                if (str_contains($environment->name, '/')) {
+                    $environment->name = str_replace('/', '-', $environment->name);
+                    $environment->save();
+                }
+            }
+        }
+    }
+}

app/Console/Commands/NotifyDemo.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace App\Console\Commands;
+
+use Illuminate\Console\Command;
+
+use function Termwind\ask;
+use function Termwind\render;
+use function Termwind\style;
+
+class NotifyDemo extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'app:demo-notify {channel?}';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Send a demo notification, to a given channel. Run to see options.';
+
+    /**
+     * Execute the console command.
+     */
+    public function handle()
+    {
+        $channel = $this->argument('channel');
+
+        if (blank($channel)) {
+            $this->showHelp();
+
+            return;
+        }
+
+        ray($channel);
+    }
+
+    private function showHelp()
+    {
+        style('coolify')->color('#9333EA');
+        style('title-box')->apply('mt-1 px-2 py-1 bg-coolify');
+
+        render(
+            <<<'HTML'
+        <div>
+            <div class="title-box">
+                Coolify
+            </div>
+            <p class="mt-1 ml-1 ">
+              Demo Notify <strong class="text-coolify">=></strong> Send a demo notification to a given channel.
+            </p>
+            <p class="px-1 mt-1 ml-1 bg-coolify">
+              php artisan app:demo-notify {channel}
+            </p>
+            <div class="my-1">
+                <div class="text-yellow-500"> Channels: </div>
+                <ul class="text-coolify">
+                    <li>email</li>
+                    <li>slack</li>
+                    <li>discord</li>
+                    <li>telegram</li>
+                </ul>
+            </div>
+        </div>
+        HTML
+        );
+
+        ask(<<<'HTML'
+        <div class="mr-1">
+            In which manner you wish a <strong class="text-coolify">coolified</strong> notification?
+        </div>
+        HTML, ['email', 'slack', 'discord', 'telegram']);
+    }
+}

app/Console/Commands/OpenApi.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Process;
+
+class OpenApi extends Command
+{
+    protected $signature = 'openapi';
+
+    protected $description = 'Generate OpenApi file.';
+
+    public function handle()
+    {
+        // Generate OpenAPI documentation
+        echo "Generating OpenAPI documentation.\n";
+        $process = Process::run(['/var/www/html/vendor/bin/openapi', 'app', '-o', 'openapi.yaml']);
+        $error = $process->errorOutput();
+        $error = preg_replace('/^.*an object literal,.*$/m', '', $error);
+        $error = preg_replace('/^\h*\v+/m', '', $error);
+        echo $error;
+        echo $process->output();
+
+    }
+}

app/Console/Commands/RootChangeEmail.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\User;
+use Illuminate\Console\Command;
+
+class RootChangeEmail extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'root:change-email';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Change Root Email';
+
+    /**
+     * Execute the console command.
+     */
+    public function handle()
+    {
+        //
+        $this->info('You are about to change the root user\'s email.');
+        $email = $this->ask('Give me a new email for root user');
+        $this->info('Updating root email...');
+        try {
+            User::find(0)->update(['email' => $email]);
+            $this->info('Root user\'s email updated successfully.');
+        } catch (\Exception $e) {
+            $this->error('Failed to update root user\'s email.');
+
+            return;
+        }
+    }
+}

app/Console/Commands/RootResetPassword.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\User;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Hash;
+
+use function Laravel\Prompts\password;
+
+class RootResetPassword extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'root:reset-password';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Reset Root Password';
+
+    /**
+     * Execute the console command.
+     */
+    public function handle()
+    {
+        $this->info('You are about to reset the root password.');
+        $password = password('Give me a new password for root user: ');
+        $passwordAgain = password('Again');
+        if ($password != $passwordAgain) {
+            $this->error('Passwords do not match.');
+
+            return;
+        }
+        $this->info('Updating root password...');
+        try {
+            User::find(0)->update(['password' => Hash::make($password)]);
+            $this->info('Root password updated successfully.');
+        } catch (\Exception $e) {
+            $this->error('Failed to update root password.');
+
+            return;
+        }
+    }
+}

app/Console/Commands/Scheduler.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Console\Commands;
+
+use Illuminate\Console\Command;
+
+class Scheduler extends Command
+{
+    protected $signature = 'start:scheduler';
+
+    protected $description = 'Start Scheduler';
+
+    public function handle()
+    {
+        if (config('coolify.is_scheduler_enabled')) {
+            $this->info('Scheduler is enabled. Starting.');
+            $this->call('schedule:work');
+            exit(0);
+        } else {
+            exit(0);
+        }
+    }
+}