Merge branch 'next' into next

.AI_INSTRUCTIONS_SYNC.md

@@ -0,0 +1,156 @@
+# AI Instructions Synchronization Guide
+
+This document explains how AI instructions are organized and synchronized across different AI tools used with Coolify.
+
+## Overview
+
+Coolify maintains AI instructions in two parallel systems:
+
+1. **CLAUDE.md** - For Claude Code (claude.ai/code)
+2. **.cursor/rules/** - For Cursor IDE and other AI assistants
+
+Both systems share core principles but are optimized for their respective workflows.
+
+## Structure
+
+### CLAUDE.md
+- **Purpose**: Condensed, workflow-focused guide for Claude Code
+- **Format**: Single markdown file
+- **Includes**:
+  - Quick-reference development commands
+  - High-level architecture overview
+  - Core patterns and guidelines
+  - Embedded Laravel Boost guidelines
+  - References to detailed .cursor/rules/ documentation
+
+### .cursor/rules/
+- **Purpose**: Detailed, topic-specific documentation
+- **Format**: Multiple .mdc files organized by topic
+- **Structure**:
+  - `README.mdc` - Main index and overview
+  - `cursor_rules.mdc` - Maintenance guidelines
+  - Topic-specific files (testing-patterns.mdc, security-patterns.mdc, etc.)
+- **Used by**: Cursor IDE, Claude Code (for detailed reference), other AI assistants
+
+## Cross-References
+
+Both systems reference each other:
+
+- **CLAUDE.md** → references `.cursor/rules/` for detailed documentation
+- **.cursor/rules/README.mdc** → references `CLAUDE.md` for Claude Code workflow
+- **.cursor/rules/cursor_rules.mdc** → notes that changes should sync with CLAUDE.md
+
+## Maintaining Consistency
+
+When updating AI instructions, follow these guidelines:
+
+### 1. Core Principles (MUST be consistent)
+- Laravel version (currently Laravel 12)
+- PHP version (8.4)
+- Testing execution rules (Docker for Feature tests, mocking for Unit tests)
+- Security patterns and authorization requirements
+- Code style requirements (Pint, PSR-12)
+
+### 2. Where to Make Changes
+
+**For workflow changes** (how to run commands, development setup):
+- Primary: `CLAUDE.md`
+- Secondary: `.cursor/rules/development-workflow.mdc`
+
+**For architectural patterns** (how code should be structured):
+- Primary: `.cursor/rules/` topic files
+- Secondary: Reference in `CLAUDE.md` "Additional Documentation" section
+
+**For testing patterns**:
+- Both: Must be synchronized
+- `CLAUDE.md` - Contains condensed testing execution rules
+- `.cursor/rules/testing-patterns.mdc` - Contains detailed examples and patterns
+
+### 3. Update Checklist
+
+When making significant changes:
+
+- [ ] Identify if change affects core principles (version numbers, critical patterns)
+- [ ] Update primary location (CLAUDE.md or .cursor/rules/)
+- [ ] Check if update affects cross-referenced content
+- [ ] Update secondary location if needed
+- [ ] Verify cross-references are still accurate
+- [ ] Run: `./vendor/bin/pint CLAUDE.md .cursor/rules/*.mdc` (if applicable)
+
+### 4. Common Inconsistencies to Watch
+
+- **Version numbers**: Laravel, PHP, package versions
+- **Testing instructions**: Docker execution requirements
+- **File paths**: Ensure relative paths work from root
+- **Command syntax**: Docker commands, artisan commands
+- **Architecture decisions**: Laravel 10 structure vs Laravel 12+ structure
+
+## File Organization
+
+```
+/
+├── CLAUDE.md                          # Claude Code instructions (condensed)
+├── .AI_INSTRUCTIONS_SYNC.md          # This file
+└── .cursor/
+    └── rules/
+        ├── README.mdc                 # Index and overview
+        ├── cursor_rules.mdc           # Maintenance guide
+        ├── testing-patterns.mdc       # Testing details
+        ├── development-workflow.mdc   # Dev setup details
+        ├── security-patterns.mdc      # Security details
+        ├── application-architecture.mdc
+        ├── deployment-architecture.mdc
+        ├── database-patterns.mdc
+        ├── frontend-patterns.mdc
+        ├── api-and-routing.mdc
+        ├── form-components.mdc
+        ├── technology-stack.mdc
+        ├── project-overview.mdc
+        └── laravel-boost.mdc          # Laravel-specific patterns
+```
+
+## Recent Updates
+
+### 2025-10-07
+- ✅ Added cross-references between CLAUDE.md and .cursor/rules/
+- ✅ Synchronized Laravel version (12) across all files
+- ✅ Added comprehensive testing execution rules (Docker for Feature tests)
+- ✅ Added test design philosophy (prefer mocking over database)
+- ✅ Fixed inconsistencies in testing documentation
+- ✅ Created this synchronization guide
+
+## Maintenance Commands
+
+```bash
+# Check for version inconsistencies
+grep -r "Laravel [0-9]" CLAUDE.md .cursor/rules/*.mdc
+
+# Check for PHP version consistency
+grep -r "PHP [0-9]" CLAUDE.md .cursor/rules/*.mdc
+
+# Format all documentation
+./vendor/bin/pint CLAUDE.md .cursor/rules/*.mdc
+
+# Search for specific patterns across all docs
+grep -r "pattern_to_check" CLAUDE.md .cursor/rules/
+```
+
+## Contributing
+
+When contributing documentation:
+
+1. Check both CLAUDE.md and .cursor/rules/ for existing documentation
+2. Add to appropriate location(s) based on guidelines above
+3. Add cross-references if creating new patterns
+4. Update this file if changing organizational structure
+5. Verify consistency before submitting PR
+
+## Questions?
+
+If unsure about where to document something:
+
+- **Quick reference / workflow** → CLAUDE.md
+- **Detailed patterns / examples** → .cursor/rules/[topic].mdc
+- **Both?** → Start with .cursor/rules/, then reference in CLAUDE.md
+
+When in doubt, prefer detailed documentation in .cursor/rules/ and concise references in CLAUDE.md.

.cursor/rules/README.mdc

@@ -9,6 +9,10 @@ alwaysApply: false
 
 This comprehensive set of Cursor Rules provides deep insights into **Coolify**, an open-source self-hostable alternative to Heroku/Netlify/Vercel. These rules will help you understand, navigate, and contribute to this complex Laravel-based deployment platform.
 
+> **Cross-Reference**: This directory is for **detailed, topic-specific rules** used by Cursor IDE and other AI assistants. For Claude Code specifically, also see **[CLAUDE.md](mdc:CLAUDE.md)** which provides a condensed, workflow-focused guide. Both systems share core principles but are optimized for their respective tools.
+>
+> **Maintaining Rules**: When updating these rules, see **[.AI_INSTRUCTIONS_SYNC.md](mdc:.AI_INSTRUCTIONS_SYNC.md)** for synchronization guidelines to keep CLAUDE.md and .cursor/rules/ consistent.
+
 ## Rule Categories
 
 ### 🏗️ Architecture & Foundation
@@ -71,7 +75,7 @@ Coolify uses a **team-based multi-tenancy** model where:
 - **Multi-server** support with SSH connections
 
 ### 3. Technology Stack
-- **Backend**: Laravel 11 + PHP 8.4
+- **Backend**: Laravel 12 + PHP 8.4
 - **Frontend**: Livewire 3.5 + Alpine.js + Tailwind CSS 4.1
 - **Database**: PostgreSQL 15 + Redis 7
 - **Containerization**: Docker + Docker Compose

.cursor/rules/cursor_rules.mdc

@@ -4,6 +4,12 @@ globs: .cursor/rules/*.mdc
 alwaysApply: true
 ---
 
+# Cursor Rules Maintenance Guide
+
+> **Important**: These rules in `.cursor/rules/` are shared between Cursor IDE and other AI assistants. Changes here should be reflected in **[CLAUDE.md](mdc:CLAUDE.md)** when they affect core workflows or patterns.
+>
+> **Synchronization Guide**: See **[.AI_INSTRUCTIONS_SYNC.md](mdc:.AI_INSTRUCTIONS_SYNC.md)** for detailed guidelines on maintaining consistency between CLAUDE.md and .cursor/rules/.
+
 - **Required Rule Structure:**
   ```markdown
   ---

.cursor/rules/database-patterns.mdc

@@ -142,6 +142,29 @@ Schema::create('applications', function (Blueprint $table) {
 - **Soft deletes** for audit trails
 - **Activity logging** with Spatie package
 
+### **CRITICAL: Mass Assignment Protection**
+**When adding new database columns, you MUST update the model's `$fillable` array.** Without this, Laravel will silently ignore mass assignment operations like `Model::create()` or `$model->update()`.
+
+**Checklist for new columns:**
+1. ✅ Create migration file
+2. ✅ Run migration
+3. ✅ **Add column to model's `$fillable` array**
+4. ✅ Update any Livewire components that sync this property
+5. ✅ Test that the column can be read and written
+
+**Example:**
+```php
+class Server extends BaseModel
+{
+    protected $fillable = [
+        'name',
+        'ip',
+        'port',
+        'is_validating', // ← MUST add new columns here
+    ];
+}
+```
+
 ### Relationship Patterns
 ```php
 // Typical relationship structure in Application model

.cursor/rules/laravel-boost.mdc

@@ -185,7 +185,7 @@ protected function isAccessible(User $user, ?string $path = null): bool
 
 ### Database
 - When modifying a column, the migration must include all of the attributes that were previously defined on the column. Otherwise, they will be dropped and lost.
-- Laravel 11 allows limiting eagerly loaded records natively, without external packages: `$query->latest()->limit(10);`.
+- Laravel 12 allows limiting eagerly loaded records natively, without external packages: `$query->latest()->limit(10);`.
 
 ### Models
 - Casts can and likely should be set in a `casts()` method on a model rather than the `$casts` property. Follow existing conventions from other models.

.cursor/rules/testing-patterns.mdc

@@ -5,11 +5,56 @@ alwaysApply: false
 ---
 # Coolify Testing Architecture & Patterns
 
+> **Cross-Reference**: These detailed testing patterns align with the testing guidelines in **[CLAUDE.md](mdc:CLAUDE.md)**. Both documents share the same core principles about Docker execution and mocking preferences.
+
 ## Testing Philosophy
 
 Coolify employs **comprehensive testing strategies** using modern PHP testing frameworks to ensure reliability of deployment operations, infrastructure management, and user interactions.
 
-!Important: Always run tests inside `coolify` container.
+### Test Execution Rules
+
+**CRITICAL**: Tests are categorized by database dependency:
+
+#### Unit Tests (`tests/Unit/`)
+- **MUST NOT** use database connections
+- **MUST** use mocking for models and external dependencies
+- **CAN** run outside Docker: `./vendor/bin/pest tests/Unit`
+- Purpose: Test isolated logic, helper functions, and business rules
+
+#### Feature Tests (`tests/Feature/`)
+- **MAY** use database connections (factories, migrations, models)
+- **MUST** run inside Docker container: `docker exec coolify php artisan test`
+- **MUST** use `RefreshDatabase` trait if touching database
+- Purpose: Test API endpoints, workflows, and integration scenarios
+
+**Rule of thumb**: If your test needs `Server::factory()->create()` or any database operation, it's a Feature test and MUST run in Docker.
+
+### Prefer Mocking Over Database
+
+When writing tests, always prefer mocking over real database operations:
+
+```php
+// ❌ BAD: Unit test using database
+it('extracts custom commands', function () {
+    $server = Server::factory()->create(['ip' => '1.2.3.4']);
+    $commands = extract_custom_proxy_commands($server, $yaml);
+    expect($commands)->toBeArray();
+});
+
+// ✅ GOOD: Unit test using mocking
+it('extracts custom commands', function () {
+    $server = Mockery::mock('App\Models\Server');
+    $server->shouldReceive('proxyType')->andReturn('traefik');
+    $commands = extract_custom_proxy_commands($server, $yaml);
+    expect($commands)->toBeArray();
+});
+```
+
+**Design principles for testable code:**
+- Use dependency injection instead of global state
+- Create interfaces for external dependencies (SSH, Docker, etc.)
+- Separate business logic from data persistence
+- Make functions accept interfaces instead of concrete models when possible
 
 ## Testing Framework Stack
 

.github/workflows/chore-pr-comments.yml

@@ -0,0 +1,56 @@
+name: Add comment based on label
+on:
+  pull_request_target:
+    types:
+      - labeled
+jobs:
+  add-comment:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+      contents: read
+      actions: none
+      checks: none
+      deployments: none
+      issues: none
+      packages: none
+      repository-projects: none
+      security-events: none
+      statuses: none
+    strategy:
+      matrix:
+        include:
+          - label: "⚙️ Service"
+            body: |
+              Hi @${{ github.event.pull_request.user.login }}! 👋
+
+              It appears to us that you are either adding a new service or making changes to an existing one.
+              We kindly ask you to also review and update the **Coolify Documentation** to include this new service or it's new configuration needs.
+              This will help ensure that our documentation remains accurate and up-to-date for all users.
+
+              Coolify Docs Repository: https://github.com/coollabsio/coolify-docs
+              How to Contribute a new Service to the Docs: https://coolify.io/docs/get-started/contribute/service#adding-a-new-service-template-to-the-coolify-documentation
+          - label: "🛠️ Feature"
+            body: |
+              Hi @${{ github.event.pull_request.user.login }}! 👋
+
+              It appears to us that you are adding a new feature to Coolify.
+              We kindly ask you to also update the **Coolify Documentation** to include information about this new feature.
+              This will help ensure that our documentation remains accurate and up-to-date for all users.
+
+              Coolify Docs Repository: https://github.com/coollabsio/coolify-docs
+              How to Contribute to the Docs: https://coolify.io/docs/get-started/contribute/documentation
+          # - label: "✨ Enhancement"
+          #  body: |
+          #    It appears to us that you are making an enhancement to Coolify.
+          #    We kindly ask you to also review and update the Coolify Documentation to include information about this enhancement if applicable.
+          #    This will help ensure that our documentation remains accurate and up-to-date for all users.
+    steps:
+      - name: Add comment
+        if: github.event.label.name == matrix.label
+        run: gh pr comment "$NUMBER" --body "$BODY"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_REPO: ${{ github.repository }}
+          NUMBER: ${{ github.event.pull_request.number }}
+          BODY: ${{ matrix.body }}

.github/workflows/claude.yml

@@ -16,6 +16,8 @@ jobs:
       (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
       (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
       (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && github.event.action == 'labeled' && github.event.label.name == 'Claude') ||
+      (github.event_name == 'pull_request' && github.event.action == 'labeled' && github.event.label.name == 'Claude') ||
       (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
     runs-on: ubuntu-latest
     permissions:
@@ -32,9 +34,9 @@ jobs:
 
       - name: Run Claude Code
         id: claude
-        uses: anthropics/claude-code-action@beta
+        uses: anthropics/claude-code-action@v1
         with:
-          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          anthropic_api_key: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
 
           # This is an optional setting that allows Claude to read CI results on PRs
           additional_permissions: |
@@ -61,4 +63,3 @@ jobs:
           # Optional: Custom environment variables for Claude
           # claude_env: |
           #   NODE_ENV: test
-

.github/workflows/cleanup-ghcr-untagged.yml

@@ -0,0 +1,25 @@
+name: Cleanup Untagged GHCR Images
+
+on:
+  workflow_dispatch: # Manual trigger only
+
+env:
+  GITHUB_REGISTRY: ghcr.io
+
+jobs:
+  cleanup-all-packages:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        package: ['coolify', 'coolify-helper', 'coolify-realtime', 'coolify-testing-host']
+    steps:
+      - name: Delete untagged ${{ matrix.package }} images
+        uses: actions/delete-package-versions@v5
+        with:
+          package-name: ${{ matrix.package }}
+          package-type: 'container'
+          min-versions-to-keep: 0
+          delete-only-untagged-versions: 'true'

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

@@ -23,43 +23,32 @@ env:
   IMAGE_NAME: "coollabsio/coolify"
 
 jobs:
-  amd64:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Login to ${{ env.GITHUB_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.GITHUB_REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-
-      - name: Login to ${{ env.DOCKER_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.DOCKER_REGISTRY }}
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_TOKEN }}
-
-      - name: Build and Push Image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: docker/production/Dockerfile
-          platforms: linux/amd64
-          push: true
-          tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
-
-  aarch64:
-    runs-on: [self-hosted, arm64]
+  build-push:
+    strategy:
+      matrix:
+        include:
+          - arch: amd64
+            platform: linux/amd64
+            runner: ubuntu-24.04
+          - arch: aarch64
+            platform: linux/aarch64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
     permissions:
       contents: read
       packages: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+
+      - name: Sanitize branch name for Docker tag
+        id: sanitize
+        run: |
+          # Replace slashes and other invalid characters with dashes
+          SANITIZED_NAME=$(echo "${{ github.ref_name }}" | sed 's/[\/]/-/g')
+          echo "tag=${SANITIZED_NAME}" >> $GITHUB_OUTPUT
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
 
       - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
@@ -75,25 +64,36 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_TOKEN }}
 
-      - name: Build and Push Image
+      - name: Build and Push Image (${{ matrix.arch }})
         uses: docker/build-push-action@v6
         with:
           context: .
           file: docker/production/Dockerfile
-          platforms: linux/aarch64
+          platforms: ${{ matrix.platform }}
           push: true
           tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}-${{ matrix.arch }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}-${{ matrix.arch }}
+          cache-from: |
+            type=gha,scope=build-${{ matrix.arch }}
+            type=registry,ref=${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:buildcache-${{ matrix.arch }}
+          cache-to: type=gha,mode=max,scope=build-${{ matrix.arch }}
 
   merge-manifest:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
+    needs: build-push
     permissions:
       contents: read
       packages: write
-    needs: [amd64, aarch64]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+
+      - name: Sanitize branch name for Docker tag
+        id: sanitize
+        run: |
+          # Replace slashes and other invalid characters with dashes
+          SANITIZED_NAME=$(echo "${{ github.ref_name }}" | sed 's/[\/]/-/g')
+          echo "tag=${SANITIZED_NAME}" >> $GITHUB_OUTPUT
 
       - uses: docker/setup-buildx-action@v3
 
@@ -114,14 +114,16 @@ jobs:
       - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
          docker buildx imagetools create \
-         --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64 \
-         --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
+         ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}-amd64 \
+         ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}-aarch64 \
+         --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}
 
       - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64 \
-          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}-amd64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}-aarch64 \
+          --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}
 
       - uses: sarisia/actions-status-discord@v1
         if: always()

CLAUDE.md

@@ -1,6 +1,10 @@
 # CLAUDE.md
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+This file provides guidance to **Claude Code** (claude.ai/code) when working with code in this repository.
+
+> **Note for AI Assistants**: This file is specifically for Claude Code. If you're using Cursor IDE, refer to the `.cursor/rules/` directory for detailed rule files. Both systems share core principles but are optimized for their respective workflows.
+>
+> **Maintaining Instructions**: When updating AI instructions, see [.AI_INSTRUCTIONS_SYNC.md](.AI_INSTRUCTIONS_SYNC.md) for synchronization guidelines between CLAUDE.md and .cursor/rules/.
 
 ## Project Overview
 
@@ -23,7 +27,14 @@ Only run artisan commands inside "coolify" container when in development.
 ### Code Quality
 - `./vendor/bin/pint` - Run Laravel Pint for code formatting
 - `./vendor/bin/phpstan` - Run PHPStan for static analysis
-- `./vendor/bin/pest` - Run Pest tests
+- `./vendor/bin/pest` - Run Pest tests (unit tests only, without database)
+
+### Running Tests
+**IMPORTANT**: Tests that require database connections MUST be run inside the Docker container:
+- **Inside Docker**: `docker exec coolify php artisan test` (for feature tests requiring database)
+- **Outside Docker**: `./vendor/bin/pest tests/Unit` (for pure unit tests without database dependencies)
+- Unit tests should use mocking and avoid database connections
+- Feature tests that require database must be run in the `coolify` container
 
 ## Architecture Overview
 
@@ -135,6 +146,7 @@ class MyComponent extends Component
 - State management handled on the server
 - Use wire:model for two-way data binding
 - Dispatch events for component communication
+- **CRITICAL**: Livewire component views **MUST** have exactly ONE root element. ALL content must be contained within this single root element. Placing ANY elements (`<style>`, `<script>`, `<div>`, comments, or any other HTML) outside the root element will break Livewire's component tracking and cause `wire:click` and other directives to fail silently.
 
 ### Code Organization Patterns
 - **Actions Pattern**: Use Actions for complex business logic (`app/Actions/`)
@@ -149,6 +161,7 @@ class MyComponent extends Component
 - Use database transactions for critical operations
 - Leverage query scopes for reusable queries
 - Apply indexes for performance-critical queries
+- **CRITICAL**: When adding new database columns, ALWAYS update the model's `$fillable` array to allow mass assignment
 
 ### Security Best Practices
 - **Authentication**: Multi-provider auth via Laravel Fortify & Sanctum
@@ -173,6 +186,21 @@ class MyComponent extends Component
 - **Mocking**: Use Laravel's built-in mocking for external services
 - **Database**: Use RefreshDatabase trait for test isolation
 
+#### Test Execution Environment
+**CRITICAL**: Database-dependent tests MUST run inside Docker container:
+- **Unit Tests** (`tests/Unit/`): Should NOT use database. Use mocking. Run with `./vendor/bin/pest tests/Unit`
+- **Feature Tests** (`tests/Feature/`): May use database. MUST run inside Docker with `docker exec coolify php artisan test`
+- If a test needs database (factories, migrations, etc.), it belongs in `tests/Feature/`
+- Always mock external services and SSH connections in tests
+
+#### Test Design Philosophy
+**PREFER MOCKING**: When designing features and writing tests:
+- **Design for testability**: Structure code so it can be tested without database (use dependency injection, interfaces)
+- **Mock by default**: Unit tests should mock models and external dependencies using Mockery
+- **Avoid database when possible**: If you can test the logic without database, write it as a Unit test
+- **Only use database when necessary**: Feature tests should test integration points, not isolated logic
+- **Example**: Instead of `Server::factory()->create()`, use `Mockery::mock('App\Models\Server')` in unit tests
+
 ### Routing Conventions
 - Group routes by middleware and prefix
 - Use route model binding for cleaner controllers
@@ -228,7 +256,9 @@ When developing features:
 
 ## Additional Documentation
 
-For more detailed guidelines and patterns, refer to the `.cursor/rules/` directory:
+This file contains high-level guidelines for Claude Code. For **more detailed, topic-specific documentation**, refer to the `.cursor/rules/` directory (also accessible by Cursor IDE and other AI assistants):
+
+> **Cross-Reference**: The `.cursor/rules/` directory contains comprehensive, detailed documentation organized by topic. Start with [.cursor/rules/README.mdc](.cursor/rules/README.mdc) for an overview, then explore specific topics below.
 
 ### Architecture & Patterns
 - [Application Architecture](.cursor/rules/application-architecture.mdc) - Detailed application structure
@@ -434,7 +464,7 @@ protected function isAccessible(User $user, ?string $path = null): bool
 
 ### Database
 - When modifying a column, the migration must include all of the attributes that were previously defined on the column. Otherwise, they will be dropped and lost.
-- Laravel 11 allows limiting eagerly loaded records natively, without external packages: `$query->latest()->limit(10);`.
+- Laravel 12 allows limiting eagerly loaded records natively, without external packages: `$query->latest()->limit(10);`.
 
 ### Models
 - Casts can and likely should be set in a `casts()` method on a model rather than the `$casts` property. Follow existing conventions from other models.
@@ -543,6 +573,10 @@ document.addEventListener('livewire:init', function () {
 - You must not remove any tests or test files from the tests directory without approval. These are not temporary or helper files - these are core to the application.
 - Tests should test all of the happy paths, failure paths, and weird paths.
 - Tests live in the `tests/Feature` and `tests/Unit` directories.
+- **Unit tests** MUST use mocking and avoid database. They can run outside Docker.
+- **Feature tests** can use database but MUST run inside Docker container.
+- **Design for testability**: Structure code to be testable without database when possible. Use dependency injection and interfaces.
+- **Mock by default**: Prefer `Mockery::mock()` over `Model::factory()->create()` in unit tests.
 - Pest tests look and behave like this:
 <code-snippet name="Basic Pest Test Example" lang="php">
 it('is true', function () {
@@ -551,11 +585,23 @@ it('is true', function () {
 </code-snippet>
 
 ### Running Tests
-- Run the minimal number of tests using an appropriate filter before finalizing code edits.
-- To run all tests: `php artisan test`.
-- To run all tests in a file: `php artisan test tests/Feature/ExampleTest.php`.
-- To filter on a particular test name: `php artisan test --filter=testName` (recommended after making a change to a related file).
-- When the tests relating to your changes are passing, ask the user if they would like to run the entire test suite to ensure everything is still passing.
+**IMPORTANT**: Always run tests in the correct environment based on database dependencies:
+
+**Unit Tests (no database):**
+- Run outside Docker: `./vendor/bin/pest tests/Unit`
+- Run specific file: `./vendor/bin/pest tests/Unit/ProxyCustomCommandsTest.php`
+- These tests use mocking and don't require PostgreSQL
+
+**Feature Tests (with database):**
+- Run inside Docker: `docker exec coolify php artisan test`
+- Run specific file: `docker exec coolify php artisan test tests/Feature/ExampleTest.php`
+- Filter by name: `docker exec coolify php artisan test --filter=testName`
+- These tests require PostgreSQL and use factories/migrations
+
+**General Guidelines:**
+- Run the minimal number of tests using an appropriate filter before finalizing code edits
+- When the tests relating to your changes are passing, ask the user if they would like to run the entire test suite
+- If you get database connection errors, you're running a Feature test outside Docker - move it inside
 
 ### Pest Assertions
 - When asserting status codes on a response, use the specific method like `assertForbidden` and `assertNotFound` instead of using `assertStatus(403)` or similar, e.g.:
@@ -650,7 +696,12 @@ it('has emails', function (string $email) {
 ## Test Enforcement
 
 - Every change must be programmatically tested. Write a new test or update an existing test, then run the affected tests to make sure they pass.
-- Run the minimum number of tests needed to ensure code quality and speed. Use `php artisan test` with a specific filename or filter.
+- Run the minimum number of tests needed to ensure code quality and speed.
+- **For Unit tests**: Use `./vendor/bin/pest tests/Unit/YourTest.php` (runs outside Docker)
+- **For Feature tests**: Use `docker exec coolify php artisan test --filter=YourTest` (runs inside Docker)
+- Choose the correct test type based on database dependency:
+  - No database needed? → Unit test with mocking
+  - Database needed? → Feature test in Docker
 </laravel-boost-guidelines>
 
 

README.md

@@ -53,40 +53,40 @@ Thank you so much!
 
 ## Big Sponsors
 
-* [CubePath](https://cubepath.com/?ref=coolify.io) - Dedicated Servers & Instant Deploy
-* [GlueOps](https://www.glueops.dev?ref=coolify.io) - DevOps automation and infrastructure management
+* [23M](https://23m.com?ref=coolify.io) - Your experts for high-availability hosting solutions!
 * [Algora](https://algora.io?ref=coolify.io) - Open source contribution platform
-* [Ubicloud](https://www.ubicloud.com?ref=coolify.io) - Open source cloud infrastructure platform
-* [LiquidWeb](https://liquidweb.com?ref=coolify.io) - Premium managed hosting solutions
-* [Convex](https://convex.link/coolify.io) - Open-source reactive database for web app developers
-* [Arcjet](https://arcjet.com?ref=coolify.io) - Advanced web security and performance solutions
-* [SaasyKit](https://saasykit.com?ref=coolify.io) - Complete SaaS starter kit for developers
-* [SupaGuide](https://supa.guide?ref=coolify.io) - Your comprehensive guide to Supabase
-* [Logto](https://logto.io?ref=coolify.io) - The better identity infrastructure for developers
-* [Trieve](https://trieve.ai?ref=coolify.io) - AI-powered search and analytics
-* [Supadata AI](https://supadata.ai/?ref=coolify.io) - Scrape YouTube, web, and files. Get AI-ready, clean data
-* [Darweb](https://darweb.nl/?ref=coolify.io) - Design. Develop. Deliver. Specialized in 3D CPQ Solutions
-* [Hetzner](http://htznr.li/CoolifyXHetzner) - Server, cloud, hosting, and data center solutions
-* [COMIT](https://comit.international?ref=coolify.io) - New York Times award–winning contractor
-* [Blacksmith](https://blacksmith.sh?ref=coolify.io) - Infrastructure automation platform
-* [WZ-IT](https://wz-it.com/?ref=coolify.io) - German agency for customised cloud solutions
-* [BC Direct](https://bc.direct?ref=coolify.io) - Your trusted technology consulting partner
-* [Tigris](https://www.tigrisdata.com?ref=coolify.io) - Modern developer data platform
-* [Hostinger](https://www.hostinger.com/vps/coolify-hosting?ref=coolify.io) - Web hosting and VPS solutions
-* [QuantCDN](https://www.quantcdn.io?ref=coolify.io) - Enterprise-grade content delivery network
-* [PFGLabs](https://pfglabs.com?ref=coolify.io) - Build Real Projects with Golang
-* [JobsCollider](https://jobscollider.com/remote-jobs?ref=coolify.io) - 30,000+ remote jobs for developers
-* [Juxtdigital](https://juxtdigital.com?ref=coolify.io) - Digital transformation and web solutions
-* [Cloudify.ro](https://cloudify.ro?ref=coolify.io) - Cloud hosting solutions
-* [CodeRabbit](https://coderabbit.ai?ref=coolify.io) - Cut Code Review Time & Bugs in Half
 * [American Cloud](https://americancloud.com?ref=coolify.io) - US-based cloud infrastructure services
-* [MassiveGrid](https://massivegrid.com?ref=coolify.io) - Enterprise cloud hosting solutions
-* [Syntax.fm](https://syntax.fm?ref=coolify.io) - Podcast for web developers
-* [Tolgee](https://tolgee.io?ref=coolify.io) - The open source localization platform
+* [Arcjet](https://arcjet.com?ref=coolify.io) - Advanced web security and performance solutions
+* [BC Direct](https://bc.direct?ref=coolify.io) - Your trusted technology consulting partner
+* [Blacksmith](https://blacksmith.sh?ref=coolify.io) - Infrastructure automation platform
+* [Brand.dev](https://brand.dev?ref=coolify.io) - API to personalize your product with logos, colors, and company info from any domain
+* [ByteBase](https://www.bytebase.com?ref=coolify.io) - Database CI/CD and Security at Scale
+* [CodeRabbit](https://coderabbit.ai?ref=coolify.io) - Cut Code Review Time & Bugs in Half
+* [COMIT](https://comit.international?ref=coolify.io) - New York Times award–winning contractor
 * [CompAI](https://www.trycomp.ai?ref=coolify.io) - Open source compliance automation platform
+* [Convex](https://convex.link/coolify.io) - Open-source reactive database for web app developers
+* [CubePath](https://cubepath.com/?ref=coolify.io) - Dedicated Servers & Instant Deploy
+* [Dade2](https://dade2.net/?ref=coolify.io) - IT Consulting, Cloud Solutions & System Integration
+* [Formbricks](https://formbricks.com?ref=coolify.io) - The open source feedback platform
 * [GoldenVM](https://billing.goldenvm.com?ref=coolify.io) - Premium virtual machine hosting solutions
 * [Gozunga](https://gozunga.com?ref=coolify.io) - Seriously Simple Cloud Infrastructure
+* [Hetzner](http://htznr.li/CoolifyXHetzner) - Server, cloud, hosting, and data center solutions
+* [Hostinger](https://www.hostinger.com/vps/coolify-hosting?ref=coolify.io) - Web hosting and VPS solutions
+* [JobsCollider](https://jobscollider.com/remote-jobs?ref=coolify.io) - 30,000+ remote jobs for developers
+* [Juxtdigital](https://juxtdigital.com?ref=coolify.io) - Digital PR & AI Authority Building Agency
+* [LiquidWeb](https://liquidweb.com?ref=coolify.io) - Premium managed hosting solutions
+* [Logto](https://logto.io?ref=coolify.io) - The better identity infrastructure for developers
 * [Macarne](https://macarne.com?ref=coolify.io) - Best IP Transit & Carrier Ethernet Solutions for Simplified Network Connectivity
+* [Mobb](https://vibe.mobb.ai/?ref=coolify.io) - Secure Your AI-Generated Code to Unlock Dev Productivity
+* [PFGLabs](https://pfglabs.com?ref=coolify.io) - Build Real Projects with Golang
+* [Ramnode](https://ramnode.com/?ref=coolify.io) - High Performance Cloud VPS Hosting
+* [SaasyKit](https://saasykit.com?ref=coolify.io) - Complete SaaS starter kit for developers
+* [SupaGuide](https://supa.guide?ref=coolify.io) - Your comprehensive guide to Supabase
+* [Supadata AI](https://supadata.ai/?ref=coolify.io) - Scrape YouTube, web, and files. Get AI-ready, clean data
+* [Syntax.fm](https://syntax.fm?ref=coolify.io) - Podcast for web developers
+* [Tigris](https://www.tigrisdata.com?ref=coolify.io) - Modern developer data platform
+* [Tolgee](https://tolgee.io?ref=coolify.io) - The open source localization platform
+* [Ubicloud](https://www.ubicloud.com?ref=coolify.io) - Open source cloud infrastructure platform
 
 
 ## Small Sponsors

app/Actions/Database/StartClickhouse.php

@@ -105,6 +105,8 @@ class StartClickhouse
         $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 stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
 

app/Actions/Database/StartDragonfly.php

@@ -55,11 +55,11 @@ class StartDragonfly
             $this->commands[] = "mkdir -p $this->configuration_dir/ssl";
 
             $server = $this->database->destination->server;
-            $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+            $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             if (! $caCert) {
                 $server->generateCaCertificate();
-                $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+                $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
             }
 
             if (! $caCert) {
@@ -192,6 +192,8 @@ class StartDragonfly
         if ($this->database->enable_ssl) {
             $this->commands[] = "chown -R 999:999 $this->configuration_dir/ssl/server.key $this->configuration_dir/ssl/server.crt";
         }
+        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
 

app/Actions/Database/StartKeydb.php

@@ -56,11 +56,11 @@ class StartKeydb
             $this->commands[] = "mkdir -p $this->configuration_dir/ssl";
 
             $server = $this->database->destination->server;
-            $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+            $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             if (! $caCert) {
                 $server->generateCaCertificate();
-                $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+                $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
             }
 
             if (! $caCert) {
@@ -208,6 +208,8 @@ class StartKeydb
         if ($this->database->enable_ssl) {
             $this->commands[] = "chown -R 999:999 $this->configuration_dir/ssl/server.key $this->configuration_dir/ssl/server.crt";
         }
+        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
 

app/Actions/Database/StartMariadb.php

@@ -57,11 +57,11 @@ class StartMariadb
             $this->commands[] = "mkdir -p $this->configuration_dir/ssl";
 
             $server = $this->database->destination->server;
-            $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+            $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             if (! $caCert) {
                 $server->generateCaCertificate();
-                $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+                $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
             }
 
             if (! $caCert) {
@@ -209,6 +209,8 @@ class StartMariadb
         $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 stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
         if ($this->database->enable_ssl) {

app/Actions/Database/StartMongodb.php

@@ -61,11 +61,11 @@ class StartMongodb
             $this->commands[] = "mkdir -p $this->configuration_dir/ssl";
 
             $server = $this->database->destination->server;
-            $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+            $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             if (! $caCert) {
                 $server->generateCaCertificate();
-                $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+                $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
             }
 
             if (! $caCert) {
@@ -260,6 +260,8 @@ class StartMongodb
         $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 stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         if ($this->database->enable_ssl) {
             $this->commands[] = executeInDocker($this->database->uuid, 'chown mongodb:mongodb /etc/mongo/certs/server.pem');

app/Actions/Database/StartMysql.php

@@ -57,11 +57,11 @@ class StartMysql
             $this->commands[] = "mkdir -p $this->configuration_dir/ssl";
 
             $server = $this->database->destination->server;
-            $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+            $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             if (! $caCert) {
                 $server->generateCaCertificate();
-                $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+                $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
             }
 
             if (! $caCert) {
@@ -210,6 +210,8 @@ class StartMysql
         $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 stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
 
         if ($this->database->enable_ssl) {

app/Actions/Database/StartPostgresql.php

@@ -62,11 +62,11 @@ class StartPostgresql
             $this->commands[] = "mkdir -p $this->configuration_dir/ssl";
 
             $server = $this->database->destination->server;
-            $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+            $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             if (! $caCert) {
                 $server->generateCaCertificate();
-                $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+                $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
             }
 
             if (! $caCert) {
@@ -223,6 +223,8 @@ class StartPostgresql
         $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 stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         if ($this->database->enable_ssl) {
             $this->commands[] = executeInDocker($this->database->uuid, "chown {$this->database->postgres_user}:{$this->database->postgres_user} /var/lib/postgresql/certs/server.key /var/lib/postgresql/certs/server.crt");

app/Actions/Database/StartRedis.php

@@ -56,11 +56,11 @@ class StartRedis
             $this->commands[] = "mkdir -p $this->configuration_dir/ssl";
 
             $server = $this->database->destination->server;
-            $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+            $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             if (! $caCert) {
                 $server->generateCaCertificate();
-                $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+                $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
             }
 
             if (! $caCert) {
@@ -205,6 +205,8 @@ class StartRedis
         if ($this->database->enable_ssl) {
             $this->commands[] = "chown -R 999:999 $this->configuration_dir/ssl/server.key $this->configuration_dir/ssl/server.crt";
         }
+        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";
 

app/Actions/Database/StopDatabase.php

@@ -49,7 +49,7 @@ class StopDatabase
     {
         $server = $database->destination->server;
         instant_remote_process(command: [
-            "docker stop --time=$timeout $containerName",
+            "docker stop --timeout=$timeout $containerName",
             "docker rm -f $containerName",
         ], server: $server, throwError: false);
     }

app/Actions/Proxy/GetProxyConfiguration.php

@@ -33,7 +33,13 @@ class GetProxyConfiguration
         // 1. Force regenerate is requested
         // 2. Configuration file doesn't exist or is empty
         if ($forceRegenerate || empty(trim($proxy_configuration ?? ''))) {
-            $proxy_configuration = str(generate_default_proxy_configuration($server))->trim()->value();
+            // Extract custom commands from existing config before regenerating
+            $custom_commands = [];
+            if (! empty(trim($proxy_configuration ?? ''))) {
+                $custom_commands = extractCustomProxyCommands($server, $proxy_configuration);
+            }
+
+            $proxy_configuration = str(generateDefaultProxyConfiguration($server, $custom_commands))->trim()->value();
         }
 
         if (empty($proxy_configuration)) {

app/Actions/Proxy/StartProxy.php

@@ -19,6 +19,11 @@ class StartProxy
         if ((is_null($proxyType) || $proxyType === 'NONE' || $server->proxy->force_stop || $server->isBuildServer()) && $force === false) {
             return 'OK';
         }
+        $server->proxy->set('status', 'starting');
+        $server->save();
+        $server->refresh();
+        ProxyStatusChangedUI::dispatch($server->team_id);
+
         $commands = collect([]);
         $proxy_path = $server->proxyPath();
         $configuration = GetProxyConfiguration::run($server);
@@ -64,14 +69,12 @@ class StartProxy
             ]);
             $commands = $commands->merge(connectProxyToNetworks($server));
         }
-        $server->proxy->set('status', 'starting');
-        $server->save();
-        ProxyStatusChangedUI::dispatch($server->team_id);
 
         if ($async) {
             return remote_process($commands, $server, callEventOnFinish: 'ProxyStatusChanged', callEventData: $server->id);
         } else {
             instant_remote_process($commands, $server);
+
             $server->proxy->set('type', $proxyType);
             $server->save();
             ProxyStatusChanged::dispatch($server->id);

app/Actions/Server/DeleteServer.php

@@ -2,16 +2,102 @@
 
 namespace App\Actions\Server;
 
+use App\Models\CloudProviderToken;
 use App\Models\Server;
+use App\Models\Team;
+use App\Notifications\Server\HetznerDeletionFailed;
+use App\Services\HetznerService;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class DeleteServer
 {
     use AsAction;
 
-    public function handle(Server $server)
+    public function handle(int $serverId, bool $deleteFromHetzner = false, ?int $hetznerServerId = null, ?int $cloudProviderTokenId = null, ?int $teamId = null)
     {
-        StopSentinel::run($server);
-        $server->forceDelete();
+        $server = Server::withTrashed()->find($serverId);
+
+        // Delete from Hetzner even if server is already gone from Coolify
+        if ($deleteFromHetzner && ($hetznerServerId || ($server && $server->hetzner_server_id))) {
+            $this->deleteFromHetznerById(
+                $hetznerServerId ?? $server->hetzner_server_id,
+                $cloudProviderTokenId ?? $server->cloud_provider_token_id,
+                $teamId ?? $server->team_id
+            );
+        }
+
+        ray($server ? 'Deleting server from Coolify' : 'Server already deleted from Coolify, skipping Coolify deletion');
+
+        // If server is already deleted from Coolify, skip this part
+        if (! $server) {
+            return; // Server already force deleted from Coolify
+        }
+
+        ray('force deleting server from Coolify', ['server_id' => $server->id]);
+
+        try {
+            $server->forceDelete();
+        } catch (\Throwable $e) {
+            ray('Failed to force delete server from Coolify', [
+                'error' => $e->getMessage(),
+                'server_id' => $server->id,
+            ]);
+            logger()->error('Failed to force delete server from Coolify', [
+                'error' => $e->getMessage(),
+                'server_id' => $server->id,
+            ]);
+        }
+    }
+
+    private function deleteFromHetznerById(int $hetznerServerId, ?int $cloudProviderTokenId, int $teamId): void
+    {
+        try {
+            // Use the provided token, or fallback to first available team token
+            $token = null;
+
+            if ($cloudProviderTokenId) {
+                $token = CloudProviderToken::find($cloudProviderTokenId);
+            }
+
+            if (! $token) {
+                $token = CloudProviderToken::where('team_id', $teamId)
+                    ->where('provider', 'hetzner')
+                    ->first();
+            }
+
+            if (! $token) {
+                ray('No Hetzner token found for team, skipping Hetzner deletion', [
+                    'team_id' => $teamId,
+                    'hetzner_server_id' => $hetznerServerId,
+                ]);
+
+                return;
+            }
+
+            $hetznerService = new HetznerService($token->token);
+            $hetznerService->deleteServer($hetznerServerId);
+
+            ray('Deleted server from Hetzner', [
+                'hetzner_server_id' => $hetznerServerId,
+                'team_id' => $teamId,
+            ]);
+        } catch (\Throwable $e) {
+            ray('Failed to delete server from Hetzner', [
+                'error' => $e->getMessage(),
+                'hetzner_server_id' => $hetznerServerId,
+                'team_id' => $teamId,
+            ]);
+
+            // Log the error but don't prevent the server from being deleted from Coolify
+            logger()->error('Failed to delete server from Hetzner', [
+                'error' => $e->getMessage(),
+                'hetzner_server_id' => $hetznerServerId,
+                'team_id' => $teamId,
+            ]);
+
+            // Notify the team about the failure
+            $team = Team::find($teamId);
+            $team?->notify(new HetznerDeletionFailed($hetznerServerId, $teamId, $e->getMessage()));
+        }
     }
 }

app/Actions/Server/InstallDocker.php

@@ -4,7 +4,6 @@ namespace App\Actions\Server;
 
 use App\Helpers\SslHelper;
 use App\Models\Server;
-use App\Models\SslCertificate;
 use App\Models\StandaloneDocker;
 use Lorisleiva\Actions\Concerns\AsAction;
 
@@ -12,15 +11,17 @@ class InstallDocker
 {
     use AsAction;
 
+    private string $dockerVersion;
+
     public function handle(Server $server)
     {
-        $dockerVersion = config('constants.docker.minimum_required_version');
+        $this->dockerVersion = config('constants.docker.minimum_required_version');
         $supported_os_type = $server->validateOS();
         if (! $supported_os_type) {
             throw new \Exception('Server OS type is not supported for automated installation. Please install Docker manually before continuing: <a target="_blank" class="underline" href="https://coolify.io/docs/installation#manually">documentation</a>.');
         }
 
-        if (! SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->exists()) {
+        if (! $server->sslCertificates()->where('is_ca_certificate', true)->exists()) {
             $serverCert = SslHelper::generateSslCertificate(
                 commonName: 'Coolify CA Certificate',
                 serverId: $server->id,
@@ -100,7 +101,19 @@ class InstallDocker
             }
             $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}",
+            ]);
+
+            if ($supported_os_type->contains('debian')) {
+                $command = $command->merge([$this->getDebianDockerInstallCommand()]);
+            } elseif ($supported_os_type->contains('rhel')) {
+                $command = $command->merge([$this->getRhelDockerInstallCommand()]);
+            } elseif ($supported_os_type->contains('sles')) {
+                $command = $command->merge([$this->getSuseDockerInstallCommand()]);
+            } else {
+                $command = $command->merge([$this->getGenericDockerInstallCommand()]);
+            }
+
+            $command = $command->merge([
                 "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",
@@ -129,4 +142,43 @@ class InstallDocker
             return remote_process($command, $server);
         }
     }
+
+    private function getDebianDockerInstallCommand(): string
+    {
+        return "curl --max-time 300 --retry 3 https://releases.rancher.com/install-docker/{$this->dockerVersion}.sh | sh || curl --max-time 300 --retry 3 https://get.docker.com | sh -s -- --version {$this->dockerVersion} || (".
+            'install -m 0755 -d /etc/apt/keyrings && '.
+            'curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc && '.
+            'chmod a+r /etc/apt/keyrings/docker.asc && '.
+            '. /etc/os-release && '.
+            'echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian ${VERSION_CODENAME} stable" > /etc/apt/sources.list.d/docker.list && '.
+            'apt-get update && '.
+            'apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin'.
+            ')';
+    }
+
+    private function getRhelDockerInstallCommand(): string
+    {
+        return "curl https://releases.rancher.com/install-docker/{$this->dockerVersion}.sh | sh || curl https://get.docker.com | sh -s -- --version {$this->dockerVersion} || (".
+            'dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo && '.
+            'dnf install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin && '.
+            'systemctl start docker && '.
+            'systemctl enable docker'.
+            ')';
+    }
+
+    private function getSuseDockerInstallCommand(): string
+    {
+        return "curl https://releases.rancher.com/install-docker/{$this->dockerVersion}.sh | sh || curl https://get.docker.com | sh -s -- --version {$this->dockerVersion} || (".
+            'zypper addrepo https://download.docker.com/linux/sles/docker-ce.repo && '.
+            'zypper refresh && '.
+            'zypper install -y --no-confirm docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin && '.
+            'systemctl start docker && '.
+            'systemctl enable docker'.
+            ')';
+    }
+
+    private function getGenericDockerInstallCommand(): string
+    {
+        return "curl https://releases.rancher.com/install-docker/{$this->dockerVersion}.sh | sh || curl https://get.docker.com | sh -s -- --version {$this->dockerVersion}";
+    }
 }

app/Actions/Stripe/CancelSubscription.php

@@ -30,7 +30,7 @@ class CancelSubscription
         $subscriptions = collect();
 
         // Get all teams the user belongs to
-        $teams = $this->user->teams;
+        $teams = $this->user->teams()->get();
 
         foreach ($teams as $team) {
             // Only include subscriptions from teams where user is owner
@@ -49,6 +49,64 @@ class CancelSubscription
         return $subscriptions;
     }
 
+    /**
+     * Verify subscriptions exist and are active in Stripe API
+     *
+     * @return array ['verified' => Collection, 'not_found' => Collection, 'errors' => array]
+     */
+    public function verifySubscriptionsInStripe(): array
+    {
+        if (! isCloud()) {
+            return [
+                'verified' => collect(),
+                'not_found' => collect(),
+                'errors' => [],
+            ];
+        }
+
+        $stripe = new StripeClient(config('subscription.stripe_api_key'));
+        $subscriptions = $this->getSubscriptionsPreview();
+
+        $verified = collect();
+        $notFound = collect();
+        $errors = [];
+
+        foreach ($subscriptions as $subscription) {
+            try {
+                $stripeSubscription = $stripe->subscriptions->retrieve($subscription->stripe_subscription_id);
+
+                // Check if subscription is actually active in Stripe
+                if (in_array($stripeSubscription->status, ['active', 'trialing', 'past_due'])) {
+                    $verified->push([
+                        'subscription' => $subscription,
+                        'stripe_status' => $stripeSubscription->status,
+                        'current_period_end' => $stripeSubscription->current_period_end,
+                    ]);
+                } else {
+                    $notFound->push([
+                        'subscription' => $subscription,
+                        'reason' => "Status in Stripe: {$stripeSubscription->status}",
+                    ]);
+                }
+            } catch (\Stripe\Exception\InvalidRequestException $e) {
+                // Subscription doesn't exist in Stripe
+                $notFound->push([
+                    'subscription' => $subscription,
+                    'reason' => 'Not found in Stripe',
+                ]);
+            } catch (\Exception $e) {
+                $errors[] = "Error verifying subscription {$subscription->stripe_subscription_id}: ".$e->getMessage();
+                \Log::error("Error verifying subscription {$subscription->stripe_subscription_id}: ".$e->getMessage());
+            }
+        }
+
+        return [
+            'verified' => $verified,
+            'not_found' => $notFound,
+            'errors' => $errors,
+        ];
+    }
+
     public function execute(): array
     {
         if ($this->isDryRun) {

app/Actions/User/DeleteUserResources.php

@@ -24,23 +24,46 @@ class DeleteUserResources
         $services = collect();
 
         // Get all teams the user belongs to
-        $teams = $this->user->teams;
+        $teams = $this->user->teams()->get();
 
         foreach ($teams as $team) {
+            // Only delete resources from teams that will be FULLY DELETED
+            // This means: user is the ONLY member of the team
+            //
+            // DO NOT delete resources if:
+            // - User is just a member (not owner)
+            // - Team has other members (ownership will be transferred or user just removed)
+
+            $userRole = $team->pivot->role;
+            $memberCount = $team->members->count();
+
+            // Skip if user is not owner
+            if ($userRole !== 'owner') {
+                continue;
+            }
+
+            // Skip if team has other members (will be transferred/user removed, not deleted)
+            if ($memberCount > 1) {
+                continue;
+            }
+
+            // Only delete resources from teams where user is the ONLY member
+            // These teams will be fully deleted
+
             // Get all servers for this team
-            $servers = $team->servers;
+            $servers = $team->servers()->get();
 
             foreach ($servers as $server) {
-                // Get applications
-                $serverApplications = $server->applications;
+                // Get applications (custom method returns Collection)
+                $serverApplications = $server->applications();
                 $applications = $applications->merge($serverApplications);
 
-                // Get databases
-                $serverDatabases = $this->getAllDatabasesForServer($server);
+                // Get databases (custom method returns Collection)
+                $serverDatabases = $server->databases();
                 $databases = $databases->merge($serverDatabases);
 
-                // Get services
-                $serverServices = $server->services;
+                // Get services (relationship needs ->get())
+                $serverServices = $server->services()->get();
                 $services = $services->merge($serverServices);
             }
         }
@@ -105,21 +128,4 @@ class DeleteUserResources
 
         return $deletedCounts;
     }
-
-    private function getAllDatabasesForServer($server): Collection
-    {
-        $databases = collect();
-
-        // Get all standalone database types
-        $databases = $databases->merge($server->postgresqls);
-        $databases = $databases->merge($server->mysqls);
-        $databases = $databases->merge($server->mariadbs);
-        $databases = $databases->merge($server->mongodbs);
-        $databases = $databases->merge($server->redis);
-        $databases = $databases->merge($server->keydbs);
-        $databases = $databases->merge($server->dragonflies);
-        $databases = $databases->merge($server->clickhouses);
-
-        return $databases;
-    }
 }

app/Actions/User/DeleteUserServers.php

@@ -23,13 +23,13 @@ class DeleteUserServers
         $servers = collect();
 
         // Get all teams the user belongs to
-        $teams = $this->user->teams;
+        $teams = $this->user->teams()->get();
 
         foreach ($teams as $team) {
             // Only include servers from teams where user is owner or admin
             $userRole = $team->pivot->role;
             if ($userRole === 'owner' || $userRole === 'admin') {
-                $teamServers = $team->servers;
+                $teamServers = $team->servers()->get();
                 $servers = $servers->merge($teamServers);
             }
         }

app/Console/Commands/AdminRemoveUser.php

@@ -1,56 +0,0 @@
-<?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/CleanupRedis.php

@@ -7,9 +7,9 @@ use Illuminate\Support\Facades\Redis;
 
 class CleanupRedis extends Command
 {
-    protected $signature = 'cleanup:redis {--dry-run : Show what would be deleted without actually deleting} {--skip-overlapping : Skip overlapping queue cleanup}';
+    protected $signature = 'cleanup:redis {--dry-run : Show what would be deleted without actually deleting} {--skip-overlapping : Skip overlapping queue cleanup} {--clear-locks : Clear stale WithoutOverlapping locks}';
 
-    protected $description = 'Cleanup Redis (Horizon jobs, metrics, overlapping queues, and related data)';
+    protected $description = 'Cleanup Redis (Horizon jobs, metrics, overlapping queues, cache locks, and related data)';
 
     public function handle()
     {
@@ -56,6 +56,13 @@ class CleanupRedis extends Command
             $deletedCount += $overlappingCleaned;
         }
 
+        // Clean up stale cache locks (WithoutOverlapping middleware)
+        if ($this->option('clear-locks')) {
+            $this->info('Cleaning up stale cache locks...');
+            $locksCleaned = $this->cleanupCacheLocks($dryRun);
+            $deletedCount += $locksCleaned;
+        }
+
         if ($dryRun) {
             $this->info("DRY RUN: Would delete {$deletedCount} out of {$totalKeys} keys");
         } else {
@@ -273,4 +280,56 @@ class CleanupRedis extends Command
 
         return $cleanedCount;
     }
+
+    private function cleanupCacheLocks(bool $dryRun): int
+    {
+        $cleanedCount = 0;
+
+        // Use the default Redis connection (database 0) where cache locks are stored
+        $redis = Redis::connection('default');
+
+        // Get all keys matching WithoutOverlapping lock pattern
+        $allKeys = $redis->keys('*');
+        $lockKeys = [];
+
+        foreach ($allKeys as $key) {
+            // Match cache lock keys: they contain 'laravel-queue-overlap'
+            if (preg_match('/overlap/i', $key)) {
+                $lockKeys[] = $key;
+            }
+        }
+        if (empty($lockKeys)) {
+            $this->info('  No cache locks found.');
+
+            return 0;
+        }
+
+        $this->info('  Found '.count($lockKeys).' cache lock(s)');
+
+        foreach ($lockKeys as $lockKey) {
+            // Check TTL to identify stale locks
+            $ttl = $redis->ttl($lockKey);
+
+            // TTL = -1 means no expiration (stale lock!)
+            // TTL = -2 means key doesn't exist
+            // TTL > 0 means lock is valid and will expire
+            if ($ttl === -1) {
+                if ($dryRun) {
+                    $this->warn("  Would delete STALE lock (no expiration): {$lockKey}");
+                } else {
+                    $redis->del($lockKey);
+                    $this->info("  ✓ Deleted STALE lock: {$lockKey}");
+                }
+                $cleanedCount++;
+            } elseif ($ttl > 0) {
+                $this->line("  Skipping active lock (expires in {$ttl}s): {$lockKey}");
+            }
+        }
+
+        if ($cleanedCount === 0) {
+            $this->info('  No stale locks found (all locks have expiration set)');
+        }
+
+        return $cleanedCount;
+    }
 }

app/Console/Commands/CleanupStuckedResources.php

@@ -13,6 +13,7 @@ use App\Models\Server;
 use App\Models\Service;
 use App\Models\ServiceApplication;
 use App\Models\ServiceDatabase;
+use App\Models\SslCertificate;
 use App\Models\StandaloneClickhouse;
 use App\Models\StandaloneDragonfly;
 use App\Models\StandaloneKeydb;
@@ -58,6 +59,15 @@ class CleanupStuckedResources extends Command
         } catch (\Throwable $e) {
             echo "Error in cleaning stucked resources: {$e->getMessage()}\n";
         }
+        try {
+            $servers = Server::onlyTrashed()->get();
+            foreach ($servers as $server) {
+                echo "Force deleting stuck server: {$server->name}\n";
+                $server->forceDelete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck servers: {$e->getMessage()}\n";
+        }
         try {
             $applicationsDeploymentQueue = ApplicationDeploymentQueue::get();
             foreach ($applicationsDeploymentQueue as $applicationDeploymentQueue) {
@@ -427,5 +437,18 @@ class CleanupStuckedResources extends Command
         } catch (\Throwable $e) {
             echo "Error in ServiceDatabases: {$e->getMessage()}\n";
         }
+
+        try {
+            $orphanedCerts = SslCertificate::whereNotIn('server_id', function ($query) {
+                $query->select('id')->from('servers');
+            })->get();
+
+            foreach ($orphanedCerts as $cert) {
+                echo "Deleting orphaned SSL certificate: {$cert->id} (server_id: {$cert->server_id})\n";
+                $cert->delete();
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning orphaned SSL certificates: {$e->getMessage()}\n";
+        }
     }
 }

app/Console/Commands/ClearGlobalSearchCache.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Livewire\GlobalSearch;
+use App\Models\Team;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Cache;
+
+class ClearGlobalSearchCache extends Command
+{
+    /**
+     * The name and signature of the console command.
+     */
+    protected $signature = 'search:clear {--team= : Clear cache for specific team ID} {--all : Clear cache for all teams}';
+
+    /**
+     * The console command description.
+     */
+    protected $description = 'Clear the global search cache for testing or manual refresh';
+
+    /**
+     * Execute the console command.
+     */
+    public function handle(): int
+    {
+        if ($this->option('all')) {
+            return $this->clearAllTeamsCache();
+        }
+
+        if ($teamId = $this->option('team')) {
+            return $this->clearTeamCache($teamId);
+        }
+
+        // If no options provided, clear cache for current user's team
+        if (! auth()->check()) {
+            $this->error('No authenticated user found. Use --team=ID or --all option.');
+
+            return Command::FAILURE;
+        }
+
+        $teamId = auth()->user()->currentTeam()->id;
+
+        return $this->clearTeamCache($teamId);
+    }
+
+    private function clearTeamCache(int $teamId): int
+    {
+        $team = Team::find($teamId);
+
+        if (! $team) {
+            $this->error("Team with ID {$teamId} not found.");
+
+            return Command::FAILURE;
+        }
+
+        GlobalSearch::clearTeamCache($teamId);
+        $this->info("✓ Cleared global search cache for team: {$team->name} (ID: {$teamId})");
+
+        return Command::SUCCESS;
+    }
+
+    private function clearAllTeamsCache(): int
+    {
+        $teams = Team::all();
+
+        if ($teams->isEmpty()) {
+            $this->warn('No teams found.');
+
+            return Command::SUCCESS;
+        }
+
+        $count = 0;
+        foreach ($teams as $team) {
+            GlobalSearch::clearTeamCache($team->id);
+            $count++;
+        }
+
+        $this->info("✓ Cleared global search cache for {$count} team(s)");
+
+        return Command::SUCCESS;
+    }
+}

app/Console/Commands/Cloud/CloudDeleteUser.php

@@ -1,722 +0,0 @@
-<?php
-
-namespace App\Console\Commands\Cloud;
-
-use App\Actions\Stripe\CancelSubscription;
-use App\Actions\User\DeleteUserResources;
-use App\Actions\User\DeleteUserServers;
-use App\Actions\User\DeleteUserTeams;
-use App\Models\User;
-use Illuminate\Console\Command;
-use Illuminate\Support\Facades\DB;
-use Illuminate\Support\Facades\Log;
-
-class CloudDeleteUser extends Command
-{
-    protected $signature = 'cloud:delete-user {email} 
-                            {--dry-run : Preview what will be deleted without actually deleting}
-                            {--skip-stripe : Skip Stripe subscription cancellation}
-                            {--skip-resources : Skip resource deletion}';
-
-    protected $description = 'Delete a user from the cloud instance with phase-by-phase confirmation';
-
-    private bool $isDryRun = false;
-
-    private bool $skipStripe = false;
-
-    private bool $skipResources = false;
-
-    private User $user;
-
-    public function handle()
-    {
-        if (! isCloud()) {
-            $this->error('This command is only available on cloud instances.');
-
-            return 1;
-        }
-
-        $email = $this->argument('email');
-        $this->isDryRun = $this->option('dry-run');
-        $this->skipStripe = $this->option('skip-stripe');
-        $this->skipResources = $this->option('skip-resources');
-
-        if ($this->isDryRun) {
-            $this->info('🔍 DRY RUN MODE - No data will be deleted');
-            $this->newLine();
-        }
-
-        try {
-            $this->user = User::whereEmail($email)->firstOrFail();
-        } catch (\Exception $e) {
-            $this->error("User with email '{$email}' not found.");
-
-            return 1;
-        }
-
-        $this->logAction("Starting user deletion process for: {$email}");
-
-        // Phase 1: Show User Overview (outside transaction)
-        if (! $this->showUserOverview()) {
-            $this->info('User deletion cancelled.');
-
-            return 0;
-        }
-
-        // If not dry run, wrap everything in a transaction
-        if (! $this->isDryRun) {
-            try {
-                DB::beginTransaction();
-
-                // Phase 2: Delete Resources
-                if (! $this->skipResources) {
-                    if (! $this->deleteResources()) {
-                        DB::rollBack();
-                        $this->error('User deletion failed at resource deletion phase. All changes rolled back.');
-
-                        return 1;
-                    }
-                }
-
-                // Phase 3: Delete Servers
-                if (! $this->deleteServers()) {
-                    DB::rollBack();
-                    $this->error('User deletion failed at server deletion phase. All changes rolled back.');
-
-                    return 1;
-                }
-
-                // Phase 4: Handle Teams
-                if (! $this->handleTeams()) {
-                    DB::rollBack();
-                    $this->error('User deletion failed at team handling phase. All changes rolled back.');
-
-                    return 1;
-                }
-
-                // Phase 5: Cancel Stripe Subscriptions
-                if (! $this->skipStripe && isCloud()) {
-                    if (! $this->cancelStripeSubscriptions()) {
-                        DB::rollBack();
-                        $this->error('User deletion failed at Stripe cancellation phase. All changes rolled back.');
-
-                        return 1;
-                    }
-                }
-
-                // Phase 6: Delete User Profile
-                if (! $this->deleteUserProfile()) {
-                    DB::rollBack();
-                    $this->error('User deletion failed at final phase. All changes rolled back.');
-
-                    return 1;
-                }
-
-                // Commit the transaction
-                DB::commit();
-
-                $this->newLine();
-                $this->info('✅ User deletion completed successfully!');
-                $this->logAction("User deletion completed for: {$email}");
-
-            } catch (\Exception $e) {
-                DB::rollBack();
-                $this->error('An error occurred during user deletion: '.$e->getMessage());
-                $this->logAction("User deletion failed for {$email}: ".$e->getMessage());
-
-                return 1;
-            }
-        } else {
-            // Dry run mode - just run through the phases without transaction
-            // Phase 2: Delete Resources
-            if (! $this->skipResources) {
-                if (! $this->deleteResources()) {
-                    $this->info('User deletion would be cancelled at resource deletion phase.');
-
-                    return 0;
-                }
-            }
-
-            // Phase 3: Delete Servers
-            if (! $this->deleteServers()) {
-                $this->info('User deletion would be cancelled at server deletion phase.');
-
-                return 0;
-            }
-
-            // Phase 4: Handle Teams
-            if (! $this->handleTeams()) {
-                $this->info('User deletion would be cancelled at team handling phase.');
-
-                return 0;
-            }
-
-            // Phase 5: Cancel Stripe Subscriptions
-            if (! $this->skipStripe && isCloud()) {
-                if (! $this->cancelStripeSubscriptions()) {
-                    $this->info('User deletion would be cancelled at Stripe cancellation phase.');
-
-                    return 0;
-                }
-            }
-
-            // Phase 6: Delete User Profile
-            if (! $this->deleteUserProfile()) {
-                $this->info('User deletion would be cancelled at final phase.');
-
-                return 0;
-            }
-
-            $this->newLine();
-            $this->info('✅ DRY RUN completed successfully! No data was deleted.');
-        }
-
-        return 0;
-    }
-
-    private function showUserOverview(): bool
-    {
-        $this->info('═══════════════════════════════════════');
-        $this->info('PHASE 1: USER OVERVIEW');
-        $this->info('═══════════════════════════════════════');
-        $this->newLine();
-
-        $teams = $this->user->teams;
-        $ownedTeams = $teams->filter(fn ($team) => $team->pivot->role === 'owner');
-        $memberTeams = $teams->filter(fn ($team) => $team->pivot->role !== 'owner');
-
-        // Collect all servers from all teams
-        $allServers = collect();
-        $allApplications = collect();
-        $allDatabases = collect();
-        $allServices = collect();
-        $activeSubscriptions = collect();
-
-        foreach ($teams as $team) {
-            $servers = $team->servers;
-            $allServers = $allServers->merge($servers);
-
-            foreach ($servers as $server) {
-                $resources = $server->definedResources();
-                foreach ($resources as $resource) {
-                    if ($resource instanceof \App\Models\Application) {
-                        $allApplications->push($resource);
-                    } elseif ($resource instanceof \App\Models\Service) {
-                        $allServices->push($resource);
-                    } else {
-                        $allDatabases->push($resource);
-                    }
-                }
-            }
-
-            if ($team->subscription && $team->subscription->stripe_subscription_id) {
-                $activeSubscriptions->push($team->subscription);
-            }
-        }
-
-        $this->table(
-            ['Property', 'Value'],
-            [
-                ['User', $this->user->email],
-                ['User ID', $this->user->id],
-                ['Created', $this->user->created_at->format('Y-m-d H:i:s')],
-                ['Last Login', $this->user->updated_at->format('Y-m-d H:i:s')],
-                ['Teams (Total)', $teams->count()],
-                ['Teams (Owner)', $ownedTeams->count()],
-                ['Teams (Member)', $memberTeams->count()],
-                ['Servers', $allServers->unique('id')->count()],
-                ['Applications', $allApplications->count()],
-                ['Databases', $allDatabases->count()],
-                ['Services', $allServices->count()],
-                ['Active Stripe Subscriptions', $activeSubscriptions->count()],
-            ]
-        );
-
-        $this->newLine();
-
-        $this->warn('⚠️  WARNING: This will permanently delete the user and all associated data!');
-        $this->newLine();
-
-        if (! $this->confirm('Do you want to continue with the deletion process?', false)) {
-            return false;
-        }
-
-        return true;
-    }
-
-    private function deleteResources(): bool
-    {
-        $this->newLine();
-        $this->info('═══════════════════════════════════════');
-        $this->info('PHASE 2: DELETE RESOURCES');
-        $this->info('═══════════════════════════════════════');
-        $this->newLine();
-
-        $action = new DeleteUserResources($this->user, $this->isDryRun);
-        $resources = $action->getResourcesPreview();
-
-        if ($resources['applications']->isEmpty() &&
-            $resources['databases']->isEmpty() &&
-            $resources['services']->isEmpty()) {
-            $this->info('No resources to delete.');
-
-            return true;
-        }
-
-        $this->info('Resources to be deleted:');
-        $this->newLine();
-
-        if ($resources['applications']->isNotEmpty()) {
-            $this->warn("Applications to be deleted ({$resources['applications']->count()}):");
-            $this->table(
-                ['Name', 'UUID', 'Server', 'Status'],
-                $resources['applications']->map(function ($app) {
-                    return [
-                        $app->name,
-                        $app->uuid,
-                        $app->destination->server->name,
-                        $app->status ?? 'unknown',
-                    ];
-                })->toArray()
-            );
-            $this->newLine();
-        }
-
-        if ($resources['databases']->isNotEmpty()) {
-            $this->warn("Databases to be deleted ({$resources['databases']->count()}):");
-            $this->table(
-                ['Name', 'Type', 'UUID', 'Server'],
-                $resources['databases']->map(function ($db) {
-                    return [
-                        $db->name,
-                        class_basename($db),
-                        $db->uuid,
-                        $db->destination->server->name,
-                    ];
-                })->toArray()
-            );
-            $this->newLine();
-        }
-
-        if ($resources['services']->isNotEmpty()) {
-            $this->warn("Services to be deleted ({$resources['services']->count()}):");
-            $this->table(
-                ['Name', 'UUID', 'Server'],
-                $resources['services']->map(function ($service) {
-                    return [
-                        $service->name,
-                        $service->uuid,
-                        $service->server->name,
-                    ];
-                })->toArray()
-            );
-            $this->newLine();
-        }
-
-        $this->error('⚠️  THIS ACTION CANNOT BE UNDONE!');
-        if (! $this->confirm('Are you sure you want to delete all these resources?', false)) {
-            return false;
-        }
-
-        if (! $this->isDryRun) {
-            $this->info('Deleting resources...');
-            $result = $action->execute();
-            $this->info("Deleted: {$result['applications']} applications, {$result['databases']} databases, {$result['services']} services");
-            $this->logAction("Deleted resources for user {$this->user->email}: {$result['applications']} apps, {$result['databases']} databases, {$result['services']} services");
-        }
-
-        return true;
-    }
-
-    private function deleteServers(): bool
-    {
-        $this->newLine();
-        $this->info('═══════════════════════════════════════');
-        $this->info('PHASE 3: DELETE SERVERS');
-        $this->info('═══════════════════════════════════════');
-        $this->newLine();
-
-        $action = new DeleteUserServers($this->user, $this->isDryRun);
-        $servers = $action->getServersPreview();
-
-        if ($servers->isEmpty()) {
-            $this->info('No servers to delete.');
-
-            return true;
-        }
-
-        $this->warn("Servers to be deleted ({$servers->count()}):");
-        $this->table(
-            ['ID', 'Name', 'IP', 'Description', 'Resources Count'],
-            $servers->map(function ($server) {
-                $resourceCount = $server->definedResources()->count();
-
-                return [
-                    $server->id,
-                    $server->name,
-                    $server->ip,
-                    $server->description ?? '-',
-                    $resourceCount,
-                ];
-            })->toArray()
-        );
-        $this->newLine();
-
-        $this->error('⚠️  WARNING: Deleting servers will remove all server configurations!');
-        if (! $this->confirm('Are you sure you want to delete all these servers?', false)) {
-            return false;
-        }
-
-        if (! $this->isDryRun) {
-            $this->info('Deleting servers...');
-            $result = $action->execute();
-            $this->info("Deleted {$result['servers']} servers");
-            $this->logAction("Deleted {$result['servers']} servers for user {$this->user->email}");
-        }
-
-        return true;
-    }
-
-    private function handleTeams(): bool
-    {
-        $this->newLine();
-        $this->info('═══════════════════════════════════════');
-        $this->info('PHASE 4: HANDLE TEAMS');
-        $this->info('═══════════════════════════════════════');
-        $this->newLine();
-
-        $action = new DeleteUserTeams($this->user, $this->isDryRun);
-        $preview = $action->getTeamsPreview();
-
-        // Check for edge cases first - EXIT IMMEDIATELY if found
-        if ($preview['edge_cases']->isNotEmpty()) {
-            $this->error('═══════════════════════════════════════');
-            $this->error('⚠️  EDGE CASES DETECTED - CANNOT PROCEED');
-            $this->error('═══════════════════════════════════════');
-            $this->newLine();
-
-            foreach ($preview['edge_cases'] as $edgeCase) {
-                $team = $edgeCase['team'];
-                $reason = $edgeCase['reason'];
-                $this->error("Team: {$team->name} (ID: {$team->id})");
-                $this->error("Issue: {$reason}");
-
-                // Show team members for context
-                $this->info('Current members:');
-                foreach ($team->members as $member) {
-                    $role = $member->pivot->role;
-                    $this->line("  - {$member->name} ({$member->email}) - Role: {$role}");
-                }
-
-                // Check for active resources
-                $resourceCount = 0;
-                foreach ($team->servers as $server) {
-                    $resources = $server->definedResources();
-                    $resourceCount += $resources->count();
-                }
-
-                if ($resourceCount > 0) {
-                    $this->warn("  ⚠️  This team has {$resourceCount} active resources!");
-                }
-
-                // Show subscription details if relevant
-                if ($team->subscription && $team->subscription->stripe_subscription_id) {
-                    $this->warn('  ⚠️  Active Stripe subscription details:');
-                    $this->warn("    Subscription ID: {$team->subscription->stripe_subscription_id}");
-                    $this->warn("    Customer ID: {$team->subscription->stripe_customer_id}");
-
-                    // Show other owners who could potentially take over
-                    $otherOwners = $team->members
-                        ->where('id', '!=', $this->user->id)
-                        ->filter(function ($member) {
-                            return $member->pivot->role === 'owner';
-                        });
-
-                    if ($otherOwners->isNotEmpty()) {
-                        $this->info('  Other owners who could take over billing:');
-                        foreach ($otherOwners as $owner) {
-                            $this->line("    - {$owner->name} ({$owner->email})");
-                        }
-                    }
-                }
-
-                $this->newLine();
-            }
-
-            $this->error('Please resolve these issues manually before retrying:');
-
-            // Check if any edge case involves subscription payment issues
-            $hasSubscriptionIssue = $preview['edge_cases']->contains(function ($edgeCase) {
-                return str_contains($edgeCase['reason'], 'Stripe subscription');
-            });
-
-            if ($hasSubscriptionIssue) {
-                $this->info('For teams with subscription payment issues:');
-                $this->info('1. Cancel the subscription through Stripe dashboard, OR');
-                $this->info('2. Transfer the subscription to another owner\'s payment method, OR');
-                $this->info('3. Have the other owner create a new subscription after cancelling this one');
-                $this->newLine();
-            }
-
-            $hasNoOwnerReplacement = $preview['edge_cases']->contains(function ($edgeCase) {
-                return str_contains($edgeCase['reason'], 'No suitable owner replacement');
-            });
-
-            if ($hasNoOwnerReplacement) {
-                $this->info('For teams with no suitable owner replacement:');
-                $this->info('1. Assign an admin role to a trusted member, OR');
-                $this->info('2. Transfer team resources to another team, OR');
-                $this->info('3. Delete the team manually if no longer needed');
-                $this->newLine();
-            }
-
-            $this->error('USER DELETION ABORTED DUE TO EDGE CASES');
-            $this->logAction("User deletion aborted for {$this->user->email}: Edge cases in team handling");
-
-            // Exit immediately - don't proceed with deletion
-            if (! $this->isDryRun) {
-                DB::rollBack();
-            }
-            exit(1);
-        }
-
-        if ($preview['to_delete']->isEmpty() &&
-            $preview['to_transfer']->isEmpty() &&
-            $preview['to_leave']->isEmpty()) {
-            $this->info('No team changes needed.');
-
-            return true;
-        }
-
-        if ($preview['to_delete']->isNotEmpty()) {
-            $this->warn('Teams to be DELETED (user is the only member):');
-            $this->table(
-                ['ID', 'Name', 'Resources', 'Subscription'],
-                $preview['to_delete']->map(function ($team) {
-                    $resourceCount = 0;
-                    foreach ($team->servers as $server) {
-                        $resourceCount += $server->definedResources()->count();
-                    }
-                    $hasSubscription = $team->subscription && $team->subscription->stripe_subscription_id
-                        ? '⚠️ YES - '.$team->subscription->stripe_subscription_id
-                        : 'No';
-
-                    return [
-                        $team->id,
-                        $team->name,
-                        $resourceCount,
-                        $hasSubscription,
-                    ];
-                })->toArray()
-            );
-            $this->newLine();
-        }
-
-        if ($preview['to_transfer']->isNotEmpty()) {
-            $this->warn('Teams where ownership will be TRANSFERRED:');
-            $this->table(
-                ['Team ID', 'Team Name', 'New Owner', 'New Owner Email'],
-                $preview['to_transfer']->map(function ($item) {
-                    return [
-                        $item['team']->id,
-                        $item['team']->name,
-                        $item['new_owner']->name,
-                        $item['new_owner']->email,
-                    ];
-                })->toArray()
-            );
-            $this->newLine();
-        }
-
-        if ($preview['to_leave']->isNotEmpty()) {
-            $this->warn('Teams where user will be REMOVED (other owners/admins exist):');
-            $userId = $this->user->id;
-            $this->table(
-                ['ID', 'Name', 'User Role', 'Other Members'],
-                $preview['to_leave']->map(function ($team) use ($userId) {
-                    $userRole = $team->members->where('id', $userId)->first()->pivot->role;
-                    $otherMembers = $team->members->count() - 1;
-
-                    return [
-                        $team->id,
-                        $team->name,
-                        $userRole,
-                        $otherMembers,
-                    ];
-                })->toArray()
-            );
-            $this->newLine();
-        }
-
-        $this->error('⚠️  WARNING: Team changes affect access control and ownership!');
-        if (! $this->confirm('Are you sure you want to proceed with these team changes?', false)) {
-            return false;
-        }
-
-        if (! $this->isDryRun) {
-            $this->info('Processing team changes...');
-            $result = $action->execute();
-            $this->info("Teams deleted: {$result['deleted']}, ownership transferred: {$result['transferred']}, left: {$result['left']}");
-            $this->logAction("Team changes for user {$this->user->email}: deleted {$result['deleted']}, transferred {$result['transferred']}, left {$result['left']}");
-        }
-
-        return true;
-    }
-
-    private function cancelStripeSubscriptions(): bool
-    {
-        $this->newLine();
-        $this->info('═══════════════════════════════════════');
-        $this->info('PHASE 5: CANCEL STRIPE SUBSCRIPTIONS');
-        $this->info('═══════════════════════════════════════');
-        $this->newLine();
-
-        $action = new CancelSubscription($this->user, $this->isDryRun);
-        $subscriptions = $action->getSubscriptionsPreview();
-
-        if ($subscriptions->isEmpty()) {
-            $this->info('No Stripe subscriptions to cancel.');
-
-            return true;
-        }
-
-        $this->info('Stripe subscriptions to cancel:');
-        $this->newLine();
-
-        $totalMonthlyValue = 0;
-        foreach ($subscriptions as $subscription) {
-            $team = $subscription->team;
-            $planId = $subscription->stripe_plan_id;
-
-            // Try to get the price from config
-            $monthlyValue = $this->getSubscriptionMonthlyValue($planId);
-            $totalMonthlyValue += $monthlyValue;
-
-            $this->line("  - {$subscription->stripe_subscription_id} (Team: {$team->name})");
-            if ($monthlyValue > 0) {
-                $this->line("    Monthly value: \${$monthlyValue}");
-            }
-            if ($subscription->stripe_cancel_at_period_end) {
-                $this->line('    ⚠️  Already set to cancel at period end');
-            }
-        }
-
-        if ($totalMonthlyValue > 0) {
-            $this->newLine();
-            $this->warn("Total monthly value: \${$totalMonthlyValue}");
-        }
-        $this->newLine();
-
-        $this->error('⚠️  WARNING: Subscriptions will be cancelled IMMEDIATELY (not at period end)!');
-        if (! $this->confirm('Are you sure you want to cancel all these subscriptions immediately?', false)) {
-            return false;
-        }
-
-        if (! $this->isDryRun) {
-            $this->info('Cancelling subscriptions...');
-            $result = $action->execute();
-            $this->info("Cancelled {$result['cancelled']} subscriptions, {$result['failed']} failed");
-            if ($result['failed'] > 0 && ! empty($result['errors'])) {
-                $this->error('Failed subscriptions:');
-                foreach ($result['errors'] as $error) {
-                    $this->error("  - {$error}");
-                }
-            }
-            $this->logAction("Cancelled {$result['cancelled']} Stripe subscriptions for user {$this->user->email}");
-        }
-
-        return true;
-    }
-
-    private function deleteUserProfile(): bool
-    {
-        $this->newLine();
-        $this->info('═══════════════════════════════════════');
-        $this->info('PHASE 6: DELETE USER PROFILE');
-        $this->info('═══════════════════════════════════════');
-        $this->newLine();
-
-        $this->warn('⚠️  FINAL STEP - This action is IRREVERSIBLE!');
-        $this->newLine();
-
-        $this->info('User profile to be deleted:');
-        $this->table(
-            ['Property', 'Value'],
-            [
-                ['Email', $this->user->email],
-                ['Name', $this->user->name],
-                ['User ID', $this->user->id],
-                ['Created', $this->user->created_at->format('Y-m-d H:i:s')],
-                ['Email Verified', $this->user->email_verified_at ? 'Yes' : 'No'],
-                ['2FA Enabled', $this->user->two_factor_confirmed_at ? 'Yes' : 'No'],
-            ]
-        );
-
-        $this->newLine();
-
-        $this->warn("Type 'DELETE {$this->user->email}' to confirm final deletion:");
-        $confirmation = $this->ask('Confirmation');
-
-        if ($confirmation !== "DELETE {$this->user->email}") {
-            $this->error('Confirmation text does not match. Deletion cancelled.');
-
-            return false;
-        }
-
-        if (! $this->isDryRun) {
-            $this->info('Deleting user profile...');
-
-            try {
-                $this->user->delete();
-                $this->info('User profile deleted successfully.');
-                $this->logAction("User profile deleted: {$this->user->email}");
-            } catch (\Exception $e) {
-                $this->error('Failed to delete user profile: '.$e->getMessage());
-                $this->logAction("Failed to delete user profile {$this->user->email}: ".$e->getMessage());
-
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    private function getSubscriptionMonthlyValue(string $planId): int
-    {
-        // Map plan IDs to monthly values based on config
-        $subscriptionConfigs = config('subscription');
-
-        foreach ($subscriptionConfigs as $key => $value) {
-            if ($value === $planId && str_contains($key, 'stripe_price_id_')) {
-                // Extract price from key pattern: stripe_price_id_basic_monthly -> basic
-                $planType = str($key)->after('stripe_price_id_')->before('_')->toString();
-
-                // Map to known prices (you may need to adjust these based on your actual pricing)
-                return match ($planType) {
-                    'basic' => 29,
-                    'pro' => 49,
-                    'ultimate' => 99,
-                    default => 0
-                };
-            }
-        }
-
-        return 0;
-    }
-
-    private function logAction(string $message): void
-    {
-        $logMessage = "[CloudDeleteUser] {$message}";
-
-        if ($this->isDryRun) {
-            $logMessage = "[DRY RUN] {$logMessage}";
-        }
-
-        Log::channel('single')->info($logMessage);
-
-        // Also log to a dedicated user deletion log file
-        $logFile = storage_path('logs/user-deletions.log');
-        $timestamp = now()->format('Y-m-d H:i:s');
-        file_put_contents($logFile, "[{$timestamp}] {$logMessage}\n", FILE_APPEND | LOCK_EX);
-    }
-}

app/Console/Commands/Init.php

@@ -73,7 +73,7 @@ class Init extends Command
         $this->cleanupUnusedNetworkFromCoolifyProxy();
 
         try {
-            $this->call('cleanup:redis');
+            $this->call('cleanup:redis', ['--clear-locks' => true]);
         } catch (\Throwable $e) {
             echo "Error in cleanup:redis command: {$e->getMessage()}\n";
         }

app/Events/ServerValidated.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Events;
+
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Broadcasting\PrivateChannel;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class ServerValidated implements ShouldBroadcast
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public ?int $teamId = null;
+
+    public ?string $serverUuid = null;
+
+    public function __construct(?int $teamId = null, ?string $serverUuid = null)
+    {
+        if (is_null($teamId) && auth()->check() && auth()->user()->currentTeam()) {
+            $teamId = auth()->user()->currentTeam()->id;
+        }
+        $this->teamId = $teamId;
+        $this->serverUuid = $serverUuid;
+    }
+
+    public function broadcastOn(): array
+    {
+        if (is_null($this->teamId)) {
+            return [];
+        }
+
+        return [
+            new PrivateChannel("team.{$this->teamId}"),
+        ];
+    }
+
+    public function broadcastAs(): string
+    {
+        return 'ServerValidated';
+    }
+
+    public function broadcastWith(): array
+    {
+        return [
+            'teamId' => $this->teamId,
+            'serverUuid' => $this->serverUuid,
+        ];
+    }
+}

app/Http/Controllers/Api/ApplicationsController.php

@@ -17,6 +17,7 @@ use App\Models\Server;
 use App\Models\Service;
 use App\Rules\ValidGitBranch;
 use App\Rules\ValidGitRepositoryUrl;
+use App\Services\DockerImageParser;
 use Illuminate\Http\Request;
 use Illuminate\Validation\Rule;
 use OpenApi\Attributes as OA;
@@ -1512,9 +1513,33 @@ class ApplicationsController extends Controller
             if ($return instanceof \Illuminate\Http\JsonResponse) {
                 return $return;
             }
-            if (! $request->docker_registry_image_tag) {
-                $request->offsetSet('docker_registry_image_tag', 'latest');
+            // Process docker image name and tag using DockerImageParser
+            $dockerImageName = $request->docker_registry_image_name;
+            $dockerImageTag = $request->docker_registry_image_tag;
+
+            // Build the full Docker image string for parsing
+            if ($dockerImageTag) {
+                $dockerImageString = $dockerImageName.':'.$dockerImageTag;
+            } else {
+                $dockerImageString = $dockerImageName;
             }
+
+            // Parse using DockerImageParser to normalize the image reference
+            $parser = new DockerImageParser;
+            $parser->parse($dockerImageString);
+
+            // Get normalized image name and tag
+            $normalizedImageName = $parser->getFullImageNameWithoutTag();
+
+            // Append @sha256 to image name if using digest
+            if ($parser->isImageHash() && ! str_ends_with($normalizedImageName, '@sha256')) {
+                $normalizedImageName .= '@sha256';
+            }
+
+            // Set processed values back to request
+            $request->offsetSet('docker_registry_image_name', $normalizedImageName);
+            $request->offsetSet('docker_registry_image_tag', $parser->getTag());
+
             $application = new Application;
             removeUnnecessaryFieldsFromRequest($request);
 
@@ -1868,7 +1893,6 @@ class ApplicationsController extends Controller
     public function delete_by_uuid(Request $request)
     {
         $teamId = getTeamIdFromToken();
-        $cleanup = filter_var($request->query->get('cleanup', true), FILTER_VALIDATE_BOOLEAN);
         if (is_null($teamId)) {
             return invalidTokenResponse();
         }
@@ -1887,10 +1911,10 @@ class ApplicationsController extends Controller
 
         DeleteResourceJob::dispatch(
             resource: $application,
-            deleteVolumes: $request->query->get('delete_volumes', true),
-            deleteConnectedNetworks: $request->query->get('delete_connected_networks', true),
-            deleteConfigurations: $request->query->get('delete_configurations', true),
-            dockerCleanup: $request->query->get('docker_cleanup', true)
+            deleteVolumes: $request->boolean('delete_volumes', true),
+            deleteConnectedNetworks: $request->boolean('delete_connected_networks', true),
+            deleteConfigurations: $request->boolean('delete_configurations', true),
+            dockerCleanup: $request->boolean('docker_cleanup', true)
         );
 
         return response()->json([
@@ -2469,7 +2493,7 @@ class ApplicationsController extends Controller
     )]
     public function update_env_by_uuid(Request $request)
     {
-        $allowedFields = ['key', 'value', 'is_preview', 'is_literal'];
+        $allowedFields = ['key', 'value', 'is_preview', 'is_literal', 'is_multiline', 'is_shown_once', 'is_runtime', 'is_buildtime'];
         $teamId = getTeamIdFromToken();
 
         if (is_null($teamId)) {
@@ -2497,6 +2521,8 @@ class ApplicationsController extends Controller
             'is_literal' => 'boolean',
             'is_multiline' => 'boolean',
             'is_shown_once' => 'boolean',
+            'is_runtime' => 'boolean',
+            'is_buildtime' => 'boolean',
         ]);
 
         $extraFields = array_diff(array_keys($request->all()), $allowedFields);
@@ -2692,7 +2718,7 @@ class ApplicationsController extends Controller
             ], 400);
         }
         $bulk_data = collect($bulk_data)->map(function ($item) {
-            return collect($item)->only(['key', 'value', 'is_preview',  'is_literal']);
+            return collect($item)->only(['key', 'value', 'is_preview', 'is_literal', 'is_multiline', 'is_shown_once', 'is_runtime', 'is_buildtime']);
         });
         $returnedEnvs = collect();
         foreach ($bulk_data as $item) {
@@ -2703,6 +2729,8 @@ class ApplicationsController extends Controller
                 'is_literal' => 'boolean',
                 'is_multiline' => 'boolean',
                 'is_shown_once' => 'boolean',
+                'is_runtime' => 'boolean',
+                'is_buildtime' => 'boolean',
             ]);
             if ($validator->fails()) {
                 return response()->json([
@@ -2862,7 +2890,7 @@ class ApplicationsController extends Controller
     )]
     public function create_env(Request $request)
     {
-        $allowedFields = ['key', 'value', 'is_preview',  'is_literal'];
+        $allowedFields = ['key', 'value', 'is_preview', 'is_literal', 'is_multiline', 'is_shown_once', 'is_runtime', 'is_buildtime'];
         $teamId = getTeamIdFromToken();
 
         if (is_null($teamId)) {
@@ -2885,6 +2913,8 @@ class ApplicationsController extends Controller
             'is_literal' => 'boolean',
             'is_multiline' => 'boolean',
             'is_shown_once' => 'boolean',
+            'is_runtime' => 'boolean',
+            'is_buildtime' => 'boolean',
         ]);
 
         $extraFields = array_diff(array_keys($request->all()), $allowedFields);
@@ -3124,8 +3154,8 @@ class ApplicationsController extends Controller
         if (is_null($teamId)) {
             return invalidTokenResponse();
         }
-        $force = $request->query->get('force') ?? false;
-        $instant_deploy = $request->query->get('instant_deploy') ?? false;
+        $force = $request->boolean('force', false);
+        $instant_deploy = $request->boolean('instant_deploy', false);
         $uuid = $request->route('uuid');
         if (! $uuid) {
             return response()->json(['message' => 'UUID is required.'], 400);

app/Http/Controllers/Api/DatabasesController.php

@@ -317,6 +317,10 @@ class DatabasesController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function update_by_uuid(Request $request)
@@ -593,6 +597,224 @@ class DatabasesController extends Controller
         ]);
     }
 
+    #[OA\Post(
+        summary: 'Create Backup',
+        description: 'Create a new scheduled backup configuration for a database',
+        path: '/databases/{uuid}/backups',
+        operationId: 'create-database-backup',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Databases'],
+        parameters: [
+            new OA\Parameter(
+                name: 'uuid',
+                in: 'path',
+                description: 'UUID of the database.',
+                required: true,
+                schema: new OA\Schema(
+                    type: 'string',
+                    format: 'uuid',
+                )
+            ),
+        ],
+        requestBody: new OA\RequestBody(
+            description: 'Backup configuration data',
+            required: true,
+            content: new OA\MediaType(
+                mediaType: 'application/json',
+                schema: new OA\Schema(
+                    type: 'object',
+                    required: ['frequency'],
+                    properties: [
+                        'frequency' => ['type' => 'string', 'description' => 'Backup frequency (cron expression or: every_minute, hourly, daily, weekly, monthly, yearly)'],
+                        'enabled' => ['type' => 'boolean', 'description' => 'Whether the backup is enabled', 'default' => true],
+                        'save_s3' => ['type' => 'boolean', 'description' => 'Whether to save backups to S3', 'default' => false],
+                        's3_storage_uuid' => ['type' => 'string', 'description' => 'S3 storage UUID (required if save_s3 is true)'],
+                        'databases_to_backup' => ['type' => 'string', 'description' => 'Comma separated list of databases to backup'],
+                        'dump_all' => ['type' => 'boolean', 'description' => 'Whether to dump all databases', 'default' => false],
+                        'backup_now' => ['type' => 'boolean', 'description' => 'Whether to trigger backup immediately after creation'],
+                        'database_backup_retention_amount_locally' => ['type' => 'integer', 'description' => 'Number of backups to retain locally'],
+                        'database_backup_retention_days_locally' => ['type' => 'integer', 'description' => 'Number of days to retain backups locally'],
+                        'database_backup_retention_max_storage_locally' => ['type' => 'integer', 'description' => 'Max storage (MB) for local backups'],
+                        'database_backup_retention_amount_s3' => ['type' => 'integer', 'description' => 'Number of backups to retain in S3'],
+                        'database_backup_retention_days_s3' => ['type' => 'integer', 'description' => 'Number of days to retain backups in S3'],
+                        'database_backup_retention_max_storage_s3' => ['type' => 'integer', 'description' => 'Max storage (MB) for S3 backups'],
+                    ],
+                ),
+            )
+        ),
+        responses: [
+            new OA\Response(
+                response: 201,
+                description: 'Backup configuration created successfully',
+                content: new OA\JsonContent(
+                    type: 'object',
+                    properties: [
+                        'uuid' => ['type' => 'string', 'format' => 'uuid', 'example' => '550e8400-e29b-41d4-a716-446655440000'],
+                        'message' => ['type' => 'string', 'example' => 'Backup configuration created successfully.'],
+                    ]
+                )
+            ),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+            new OA\Response(
+                response: 404,
+                ref: '#/components/responses/404',
+            ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
+        ]
+    )]
+    public function create_backup(Request $request)
+    {
+        $backupConfigFields = ['save_s3', 'enabled', 'dump_all', 'frequency', 'databases_to_backup', 'database_backup_retention_amount_locally', 'database_backup_retention_days_locally', 'database_backup_retention_max_storage_locally', 'database_backup_retention_amount_s3', 'database_backup_retention_days_s3', 'database_backup_retention_max_storage_s3', 's3_storage_uuid'];
+
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+
+        // Validate incoming request is valid JSON
+        $return = validateIncomingRequest($request);
+        if ($return instanceof \Illuminate\Http\JsonResponse) {
+            return $return;
+        }
+
+        $validator = customApiValidator($request->all(), [
+            'frequency' => 'required|string',
+            'enabled' => 'boolean',
+            'save_s3' => 'boolean',
+            'dump_all' => 'boolean',
+            'backup_now' => 'boolean|nullable',
+            's3_storage_uuid' => 'string|exists:s3_storages,uuid|nullable',
+            'databases_to_backup' => 'string|nullable',
+            'database_backup_retention_amount_locally' => 'integer|min:0',
+            'database_backup_retention_days_locally' => 'integer|min:0',
+            'database_backup_retention_max_storage_locally' => 'integer|min:0',
+            'database_backup_retention_amount_s3' => 'integer|min:0',
+            'database_backup_retention_days_s3' => 'integer|min:0',
+            'database_backup_retention_max_storage_s3' => 'integer|min:0',
+        ]);
+
+        if ($validator->fails()) {
+            return response()->json([
+                'message' => 'Validation failed.',
+                'errors' => $validator->errors(),
+            ], 422);
+        }
+
+        if (! $request->uuid) {
+            return response()->json(['message' => 'UUID is required.'], 404);
+        }
+
+        $uuid = $request->uuid;
+        $database = queryDatabaseByUuidWithinTeam($uuid, $teamId);
+        if (! $database) {
+            return response()->json(['message' => 'Database not found.'], 404);
+        }
+
+        $this->authorize('manageBackups', $database);
+
+        // Validate frequency is a valid cron expression
+        $isValid = validate_cron_expression($request->frequency);
+        if (! $isValid) {
+            return response()->json([
+                'message' => 'Validation failed.',
+                'errors' => ['frequency' => ['Invalid cron expression or frequency format.']],
+            ], 422);
+        }
+
+        // Validate S3 storage if save_s3 is true
+        if ($request->boolean('save_s3') && ! $request->filled('s3_storage_uuid')) {
+            return response()->json([
+                'message' => 'Validation failed.',
+                'errors' => ['s3_storage_uuid' => ['The s3_storage_uuid field is required when save_s3 is true.']],
+            ], 422);
+        }
+
+        if ($request->filled('s3_storage_uuid')) {
+            $existsInTeam = S3Storage::ownedByCurrentTeam()->where('uuid', $request->s3_storage_uuid)->exists();
+            if (! $existsInTeam) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => ['s3_storage_uuid' => ['The selected S3 storage is invalid for this team.']],
+                ], 422);
+            }
+        }
+
+        // Check for extra fields
+        $extraFields = array_diff(array_keys($request->all()), $backupConfigFields, ['backup_now']);
+        if (! empty($extraFields)) {
+            $errors = $validator->errors();
+            foreach ($extraFields as $field) {
+                $errors->add($field, 'This field is not allowed.');
+            }
+
+            return response()->json([
+                'message' => 'Validation failed.',
+                'errors' => $errors,
+            ], 422);
+        }
+
+        $backupData = $request->only($backupConfigFields);
+
+        // Convert s3_storage_uuid to s3_storage_id
+        if (isset($backupData['s3_storage_uuid'])) {
+            $s3Storage = S3Storage::ownedByCurrentTeam()->where('uuid', $backupData['s3_storage_uuid'])->first();
+            if ($s3Storage) {
+                $backupData['s3_storage_id'] = $s3Storage->id;
+            } elseif ($request->boolean('save_s3')) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => ['s3_storage_uuid' => ['The selected S3 storage is invalid for this team.']],
+                ], 422);
+            }
+            unset($backupData['s3_storage_uuid']);
+        }
+
+        // Set default databases_to_backup based on database type if not provided
+        if (! isset($backupData['databases_to_backup']) || empty($backupData['databases_to_backup'])) {
+            if ($database->type() === 'standalone-postgresql') {
+                $backupData['databases_to_backup'] = $database->postgres_db;
+            } elseif ($database->type() === 'standalone-mysql') {
+                $backupData['databases_to_backup'] = $database->mysql_database;
+            } elseif ($database->type() === 'standalone-mariadb') {
+                $backupData['databases_to_backup'] = $database->mariadb_database;
+            }
+        }
+
+        // Add required fields
+        $backupData['database_id'] = $database->id;
+        $backupData['database_type'] = $database->getMorphClass();
+        $backupData['team_id'] = $teamId;
+
+        // Set defaults
+        if (! isset($backupData['enabled'])) {
+            $backupData['enabled'] = true;
+        }
+
+        $backupConfig = ScheduledDatabaseBackup::create($backupData);
+
+        // Trigger immediate backup if requested
+        if ($request->backup_now) {
+            dispatch(new DatabaseBackupJob($backupConfig));
+        }
+
+        return response()->json([
+            'uuid' => $backupConfig->uuid,
+            'message' => 'Backup configuration created successfully.',
+        ], 201);
+    }
+
     #[OA\Patch(
         summary: 'Update',
         description: 'Update a specific backup configuration for a given database, identified by its UUID and the backup ID',
@@ -666,6 +888,10 @@ class DatabasesController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function update_backup(Request $request)
@@ -844,6 +1070,10 @@ class DatabasesController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_database_postgresql(Request $request)
@@ -907,6 +1137,10 @@ class DatabasesController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_database_clickhouse(Request $request)
@@ -969,6 +1203,10 @@ class DatabasesController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_database_dragonfly(Request $request)
@@ -1032,6 +1270,10 @@ class DatabasesController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_database_redis(Request $request)
@@ -1095,6 +1337,10 @@ class DatabasesController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_database_keydb(Request $request)
@@ -1161,6 +1407,10 @@ class DatabasesController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_database_mariadb(Request $request)
@@ -1227,6 +1477,10 @@ class DatabasesController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_database_mysql(Request $request)
@@ -1290,6 +1544,10 @@ class DatabasesController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_database_mongodb(Request $request)
@@ -1875,7 +2133,6 @@ class DatabasesController extends Controller
     public function delete_by_uuid(Request $request)
     {
         $teamId = getTeamIdFromToken();
-        $cleanup = filter_var($request->query->get('cleanup', true), FILTER_VALIDATE_BOOLEAN);
         if (is_null($teamId)) {
             return invalidTokenResponse();
         }
@@ -1891,10 +2148,10 @@ class DatabasesController extends Controller
 
         DeleteResourceJob::dispatch(
             resource: $database,
-            deleteVolumes: $request->query->get('delete_volumes', true),
-            deleteConnectedNetworks: $request->query->get('delete_connected_networks', true),
-            deleteConfigurations: $request->query->get('delete_configurations', true),
-            dockerCleanup: $request->query->get('docker_cleanup', true)
+            deleteVolumes: $request->boolean('delete_volumes', true),
+            deleteConnectedNetworks: $request->boolean('delete_connected_networks', true),
+            deleteConfigurations: $request->boolean('delete_configurations', true),
+            dockerCleanup: $request->boolean('docker_cleanup', true)
         );
 
         return response()->json([
@@ -1941,7 +2198,7 @@ class DatabasesController extends Controller
                 content: new OA\JsonContent(
                     type: 'object',
                     properties: [
-                        'message' => new OA\Schema(type: 'string', example: 'Backup configuration and all executions deleted.'),
+                        new OA\Property(property: 'message', type: 'string', example: 'Backup configuration and all executions deleted.'),
                     ]
                 )
             ),
@@ -1951,7 +2208,7 @@ class DatabasesController extends Controller
                 content: new OA\JsonContent(
                     type: 'object',
                     properties: [
-                        'message' => new OA\Schema(type: 'string', example: 'Backup configuration not found.'),
+                        new OA\Property(property: 'message', type: 'string', example: 'Backup configuration not found.'),
                     ]
                 )
             ),
@@ -1985,7 +2242,7 @@ class DatabasesController extends Controller
             return response()->json(['message' => 'Backup configuration not found.'], 404);
         }
 
-        $deleteS3 = filter_var($request->query->get('delete_s3', false), FILTER_VALIDATE_BOOLEAN);
+        $deleteS3 = $request->boolean('delete_s3', false);
 
         try {
             DB::beginTransaction();
@@ -2065,7 +2322,7 @@ class DatabasesController extends Controller
                 content: new OA\JsonContent(
                     type: 'object',
                     properties: [
-                        'message' => new OA\Schema(type: 'string', example: 'Backup execution deleted.'),
+                        new OA\Property(property: 'message', type: 'string', example: 'Backup execution deleted.'),
                     ]
                 )
             ),
@@ -2075,7 +2332,7 @@ class DatabasesController extends Controller
                 content: new OA\JsonContent(
                     type: 'object',
                     properties: [
-                        'message' => new OA\Schema(type: 'string', example: 'Backup execution not found.'),
+                        new OA\Property(property: 'message', type: 'string', example: 'Backup execution not found.'),
                     ]
                 )
             ),
@@ -2118,7 +2375,7 @@ class DatabasesController extends Controller
             return response()->json(['message' => 'Backup execution not found.'], 404);
         }
 
-        $deleteS3 = filter_var($request->query->get('delete_s3', false), FILTER_VALIDATE_BOOLEAN);
+        $deleteS3 = $request->boolean('delete_s3', false);
 
         try {
             if ($execution->filename) {
@@ -2171,17 +2428,18 @@ class DatabasesController extends Controller
                 content: new OA\JsonContent(
                     type: 'object',
                     properties: [
-                        'executions' => new OA\Schema(
+                        new OA\Property(
+                            property: 'executions',
                             type: 'array',
-                            items: new OA\Schema(
+                            items: new OA\Items(
                                 type: 'object',
                                 properties: [
-                                    'uuid' => ['type' => 'string'],
-                                    'filename' => ['type' => 'string'],
-                                    'size' => ['type' => 'integer'],
-                                    'created_at' => ['type' => 'string'],
-                                    'message' => ['type' => 'string'],
-                                    'status' => ['type' => 'string'],
+                                    new OA\Property(property: 'uuid', type: 'string'),
+                                    new OA\Property(property: 'filename', type: 'string'),
+                                    new OA\Property(property: 'size', type: 'integer'),
+                                    new OA\Property(property: 'created_at', type: 'string'),
+                                    new OA\Property(property: 'message', type: 'string'),
+                                    new OA\Property(property: 'status', type: 'string'),
                                 ]
                             )
                         ),

app/Http/Controllers/Api/DeployController.php

@@ -131,6 +131,161 @@ class DeployController extends Controller
         return response()->json($this->removeSensitiveData($deployment));
     }
 
+    #[OA\Post(
+        summary: 'Cancel',
+        description: 'Cancel a deployment by UUID.',
+        path: '/deployments/{uuid}/cancel',
+        operationId: 'cancel-deployment-by-uuid',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Deployments'],
+        parameters: [
+            new OA\Parameter(name: 'uuid', in: 'path', required: true, description: 'Deployment UUID', schema: new OA\Schema(type: 'string')),
+        ],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Deployment cancelled successfully.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'object',
+                            properties: [
+                                'message' => ['type' => 'string', 'example' => 'Deployment cancelled successfully.'],
+                                'deployment_uuid' => ['type' => 'string', 'example' => 'cm37r6cqj000008jm0veg5tkm'],
+                                'status' => ['type' => 'string', 'example' => 'cancelled-by-user'],
+                            ]
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 400,
+                description: 'Deployment cannot be cancelled (already finished/failed/cancelled).',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'object',
+                            properties: [
+                                'message' => ['type' => 'string', 'example' => 'Deployment cannot be cancelled. Current status: finished'],
+                            ]
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 403,
+                description: 'User doesn\'t have permission to cancel this deployment.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'object',
+                            properties: [
+                                'message' => ['type' => 'string', 'example' => 'You do not have permission to cancel this deployment.'],
+                            ]
+                        )
+                    ),
+                ]),
+            new OA\Response(
+                response: 404,
+                ref: '#/components/responses/404',
+            ),
+        ]
+    )]
+    public function cancel_deployment(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+
+        $uuid = $request->route('uuid');
+        if (! $uuid) {
+            return response()->json(['message' => 'UUID is required.'], 400);
+        }
+
+        // Find the deployment by UUID
+        $deployment = ApplicationDeploymentQueue::where('deployment_uuid', $uuid)->first();
+        if (! $deployment) {
+            return response()->json(['message' => 'Deployment not found.'], 404);
+        }
+
+        // Check if the deployment belongs to the user's team
+        $servers = Server::whereTeamId($teamId)->pluck('id');
+        if (! $servers->contains($deployment->server_id)) {
+            return response()->json(['message' => 'You do not have permission to cancel this deployment.'], 403);
+        }
+
+        // Check if deployment can be cancelled (must be queued or in_progress)
+        $cancellableStatuses = [
+            \App\Enums\ApplicationDeploymentStatus::QUEUED->value,
+            \App\Enums\ApplicationDeploymentStatus::IN_PROGRESS->value,
+        ];
+
+        if (! in_array($deployment->status, $cancellableStatuses)) {
+            return response()->json([
+                'message' => "Deployment cannot be cancelled. Current status: {$deployment->status}",
+            ], 400);
+        }
+
+        // Perform the cancellation
+        try {
+            $deployment_uuid = $deployment->deployment_uuid;
+            $kill_command = "docker rm -f {$deployment_uuid}";
+            $build_server_id = $deployment->build_server_id ?? $deployment->server_id;
+
+            // Mark deployment as cancelled
+            $deployment->update([
+                'status' => \App\Enums\ApplicationDeploymentStatus::CANCELLED_BY_USER->value,
+            ]);
+
+            // Get the server
+            $server = Server::find($build_server_id);
+
+            if ($server) {
+                // Add cancellation log entry
+                $deployment->addLogEntry('Deployment cancelled by user via API.', 'stderr');
+
+                // Check if container exists and kill it
+                $checkCommand = "docker ps -a --filter name={$deployment_uuid} --format '{{.Names}}'";
+                $containerExists = instant_remote_process([$checkCommand], $server);
+
+                if ($containerExists && str($containerExists)->trim()->isNotEmpty()) {
+                    instant_remote_process([$kill_command], $server);
+                    $deployment->addLogEntry('Deployment container stopped.');
+                } else {
+                    $deployment->addLogEntry('Deployment container not yet started. Will be cancelled when job checks status.');
+                }
+
+                // Kill running process if process ID exists
+                if ($deployment->current_process_id) {
+                    try {
+                        $processKillCommand = "kill -9 {$deployment->current_process_id}";
+                        instant_remote_process([$processKillCommand], $server);
+                    } catch (\Throwable $e) {
+                        // Process might already be gone
+                    }
+                }
+            }
+
+            return response()->json([
+                'message' => 'Deployment cancelled successfully.',
+                'deployment_uuid' => $deployment->deployment_uuid,
+                'status' => $deployment->status,
+            ]);
+        } catch (\Throwable $e) {
+            return response()->json([
+                'message' => 'Failed to cancel deployment: '.$e->getMessage(),
+            ], 500);
+        }
+    }
+
     #[OA\Get(
         summary: 'Deploy',
         description: 'Deploy by tag or uuid. `Post` request also accepted with `uuid` and `tag` json body.',

app/Http/Controllers/Api/GithubController.php

@@ -12,6 +12,88 @@ use OpenApi\Attributes as OA;
 
 class GithubController extends Controller
 {
+    private function removeSensitiveData($githubApp)
+    {
+        $githubApp->makeHidden([
+            'client_secret',
+            'webhook_secret',
+        ]);
+
+        return serializeApiResponse($githubApp);
+    }
+
+    #[OA\Get(
+        summary: 'List',
+        description: 'List all GitHub apps.',
+        path: '/github-apps',
+        operationId: 'list-github-apps',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['GitHub Apps'],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'List of GitHub apps.',
+                content: [
+                    new OA\MediaType(
+                        mediaType: 'application/json',
+                        schema: new OA\Schema(
+                            type: 'array',
+                            items: new OA\Items(
+                                type: 'object',
+                                properties: [
+                                    'id' => ['type' => 'integer'],
+                                    'uuid' => ['type' => 'string'],
+                                    'name' => ['type' => 'string'],
+                                    'organization' => ['type' => 'string', 'nullable' => true],
+                                    'api_url' => ['type' => 'string'],
+                                    'html_url' => ['type' => 'string'],
+                                    'custom_user' => ['type' => 'string'],
+                                    'custom_port' => ['type' => 'integer'],
+                                    'app_id' => ['type' => 'integer'],
+                                    'installation_id' => ['type' => 'integer'],
+                                    'client_id' => ['type' => 'string'],
+                                    'private_key_id' => ['type' => 'integer'],
+                                    'is_system_wide' => ['type' => 'boolean'],
+                                    'is_public' => ['type' => 'boolean'],
+                                    'team_id' => ['type' => 'integer'],
+                                    'type' => ['type' => 'string'],
+                                ]
+                            )
+                        )
+                    ),
+                ]
+            ),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function list_github_apps(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+
+        $githubApps = GithubApp::where(function ($query) use ($teamId) {
+            $query->where('team_id', $teamId)
+                ->orWhere('is_system_wide', true);
+        })->get();
+
+        $githubApps = $githubApps->map(function ($app) {
+            return $this->removeSensitiveData($app);
+        });
+
+        return response()->json($githubApps);
+    }
+
     #[OA\Post(
         summary: 'Create GitHub App',
         description: 'Create a new GitHub app.',
@@ -219,9 +301,10 @@ class GithubController extends Controller
                     schema: new OA\Schema(
                         type: 'object',
                         properties: [
-                            'repositories' => new OA\Items(
+                            new OA\Property(
+                                property: 'repositories',
                                 type: 'array',
-                                items: new OA\Schema(type: 'object')
+                                items: new OA\Items(type: 'object')
                             ),
                         ]
                     )
@@ -335,9 +418,10 @@ class GithubController extends Controller
                     schema: new OA\Schema(
                         type: 'object',
                         properties: [
-                            'branches' => new OA\Items(
+                            new OA\Property(
+                                property: 'branches',
                                 type: 'array',
-                                items: new OA\Schema(type: 'object')
+                                items: new OA\Items(type: 'object')
                             ),
                         ]
                     )
@@ -457,7 +541,7 @@ class GithubController extends Controller
             ),
             new OA\Response(response: 401, description: 'Unauthorized'),
             new OA\Response(response: 404, description: 'GitHub app not found'),
-            new OA\Response(response: 422, description: 'Validation error'),
+            new OA\Response(response: 422, ref: '#/components/responses/422'),
         ]
     )]
     public function update_github_app(Request $request, $github_app_id)

app/Http/Controllers/Api/OpenApi.php

@@ -40,6 +40,27 @@ use OpenApi\Attributes as OA;
                     new OA\Property(property: 'message', type: 'string', example: 'Resource not found.'),
                 ]
             )),
+        new OA\Response(
+            response: 422,
+            description: 'Validation error.',
+            content: new OA\JsonContent(
+                type: 'object',
+                properties: [
+                    new OA\Property(property: 'message', type: 'string', example: 'Validation error.'),
+                    new OA\Property(
+                        property: 'errors',
+                        type: 'object',
+                        additionalProperties: new OA\AdditionalProperties(
+                            type: 'array',
+                            items: new OA\Items(type: 'string')
+                        ),
+                        example: [
+                            'name' => ['The name field is required.'],
+                            'api_url' => ['The api url field is required.', 'The api url format is invalid.'],
+                        ]
+                    ),
+                ]
+            )),
     ],
 )]
 class OpenApi

app/Http/Controllers/Api/OtherController.php

@@ -21,8 +21,9 @@ class OtherController extends Controller
             new OA\Response(
                 response: 200,
                 description: 'Returns the version of the application',
-                content: new OA\JsonContent(
-                    type: 'string',
+                content: new OA\MediaType(
+                    mediaType: 'text/html',
+                    schema: new OA\Schema(type: 'string'),
                     example: 'v4.0.0',
                 )),
             new OA\Response(
@@ -166,8 +167,9 @@ class OtherController extends Controller
             new OA\Response(
                 response: 200,
                 description: 'Healthcheck endpoint.',
-                content: new OA\JsonContent(
-                    type: 'string',
+                content: new OA\MediaType(
+                    mediaType: 'text/html',
+                    schema: new OA\Schema(type: 'string'),
                     example: 'OK',
                 )),
             new OA\Response(

app/Http/Controllers/Api/ProjectController.php

@@ -134,6 +134,10 @@ class ProjectController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function environment_details(Request $request)
@@ -214,6 +218,10 @@ class ProjectController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_project(Request $request)
@@ -324,6 +332,10 @@ class ProjectController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function update_project(Request $request)
@@ -425,6 +437,10 @@ class ProjectController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function delete_project(Request $request)
@@ -487,6 +503,10 @@ class ProjectController extends Controller
                 response: 404,
                 description: 'Project not found.',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function get_environments(Request $request)
@@ -566,6 +586,10 @@ class ProjectController extends Controller
                 response: 409,
                 description: 'Environment with this name already exists.',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_environment(Request $request)
@@ -663,6 +687,10 @@ class ProjectController extends Controller
                 response: 404,
                 description: 'Project or environment not found.',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function delete_environment(Request $request)

app/Http/Controllers/Api/SecurityController.php

@@ -163,6 +163,10 @@ class SecurityController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_key(Request $request)
@@ -282,6 +286,10 @@ class SecurityController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function update_key(Request $request)

app/Http/Controllers/Api/ServersController.php

@@ -447,6 +447,10 @@ class ServersController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_server(Request $request)
@@ -604,6 +608,10 @@ class ServersController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function update_server(Request $request)
@@ -722,6 +730,10 @@ class ServersController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function delete_server(Request $request)
@@ -746,7 +758,13 @@ class ServersController extends Controller
             return response()->json(['message' => 'Local server cannot be deleted.'], 400);
         }
         $server->delete();
-        DeleteServer::dispatch($server);
+        DeleteServer::dispatch(
+            $server->id,
+            false, // Don't delete from Hetzner via API
+            $server->hetzner_server_id,
+            $server->cloud_provider_token_id,
+            $server->team_id
+        );
 
         return response()->json(['message' => 'Server deleted.']);
     }
@@ -790,6 +808,10 @@ class ServersController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function validate_server(Request $request)

app/Http/Controllers/Api/ServicesController.php

@@ -235,6 +235,10 @@ class ServicesController extends Controller
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_service(Request $request)
@@ -324,9 +328,23 @@ class ServicesController extends Controller
                 });
             }
             if ($oneClickService) {
-                $service_payload = [
+                $dockerComposeRaw = base64_decode($oneClickService);
+
+                // Validate for command injection BEFORE creating service
+                try {
+                    validateDockerComposeForInjection($dockerComposeRaw);
+                } catch (\Exception $e) {
+                    return response()->json([
+                        'message' => 'Validation failed.',
+                        'errors' => [
+                            'docker_compose_raw' => $e->getMessage(),
+                        ],
+                    ], 422);
+                }
+
+                $servicePayload = [
                     'name' => "$oneClickServiceName-".str()->random(10),
-                    'docker_compose_raw' => base64_decode($oneClickService),
+                    'docker_compose_raw' => $dockerComposeRaw,
                     'environment_id' => $environment->id,
                     'service_type' => $oneClickServiceName,
                     'server_id' => $server->id,
@@ -334,9 +352,9 @@ class ServicesController extends Controller
                     'destination_type' => $destination->getMorphClass(),
                 ];
                 if ($oneClickServiceName === 'cloudflared') {
-                    data_set($service_payload, 'connect_to_docker_network', true);
+                    data_set($servicePayload, 'connect_to_docker_network', true);
                 }
-                $service = Service::create($service_payload);
+                $service = Service::create($servicePayload);
                 $service->name = "$oneClickServiceName-".$service->uuid;
                 $service->save();
                 if ($oneClickDotEnvs?->count() > 0) {
@@ -458,6 +476,18 @@ class ServicesController extends Controller
             $dockerCompose = base64_decode($request->docker_compose_raw);
             $dockerComposeRaw = Yaml::dump(Yaml::parse($dockerCompose), 10, 2, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK);
 
+            // Validate for command injection BEFORE saving to database
+            try {
+                validateDockerComposeForInjection($dockerComposeRaw);
+            } catch (\Exception $e) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => [
+                        'docker_compose_raw' => $e->getMessage(),
+                    ],
+                ], 422);
+            }
+
             $connectToDockerNetwork = $request->connect_to_docker_network ?? false;
             $instantDeploy = $request->instant_deploy ?? false;
 
@@ -619,10 +649,10 @@ class ServicesController extends Controller
 
         DeleteResourceJob::dispatch(
             resource: $service,
-            deleteVolumes: $request->query->get('delete_volumes', true),
-            deleteConnectedNetworks: $request->query->get('delete_connected_networks', true),
-            deleteConfigurations: $request->query->get('delete_configurations', true),
-            dockerCleanup: $request->query->get('docker_cleanup', true)
+            deleteVolumes: $request->boolean('delete_volumes', true),
+            deleteConnectedNetworks: $request->boolean('delete_connected_networks', true),
+            deleteConfigurations: $request->boolean('delete_configurations', true),
+            dockerCleanup: $request->boolean('docker_cleanup', true)
         );
 
         return response()->json([
@@ -704,6 +734,10 @@ class ServicesController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function update_by_uuid(Request $request)
@@ -769,6 +803,19 @@ class ServicesController extends Controller
             }
             $dockerCompose = base64_decode($request->docker_compose_raw);
             $dockerComposeRaw = Yaml::dump(Yaml::parse($dockerCompose), 10, 2, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK);
+
+            // Validate for command injection BEFORE saving to database
+            try {
+                validateDockerComposeForInjection($dockerComposeRaw);
+            } catch (\Exception $e) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => [
+                        'docker_compose_raw' => $e->getMessage(),
+                    ],
+                ], 422);
+            }
+
             $service->docker_compose_raw = $dockerComposeRaw;
         }
 
@@ -954,6 +1001,10 @@ class ServicesController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function update_env_by_uuid(Request $request)
@@ -1075,6 +1126,10 @@ class ServicesController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_bulk_envs(Request $request)
@@ -1191,6 +1246,10 @@ class ServicesController extends Controller
                 response: 404,
                 ref: '#/components/responses/404',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_env(Request $request)

app/Http/Kernel.php

@@ -14,7 +14,7 @@ class Kernel extends HttpKernel
      * @var array<int, class-string|string>
      */
     protected $middleware = [
-        // \App\Http\Middleware\TrustHosts::class,
+        \App\Http\Middleware\TrustHosts::class,
         \App\Http\Middleware\TrustProxies::class,
         \Illuminate\Http\Middleware\HandleCors::class,
         \App\Http\Middleware\PreventRequestsDuringMaintenance::class,

app/Http/Middleware/TrustHosts.php

@@ -2,10 +2,44 @@
 
 namespace App\Http\Middleware;
 
+use App\Models\InstanceSettings;
 use Illuminate\Http\Middleware\TrustHosts as Middleware;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Cache;
+use Spatie\Url\Url;
 
 class TrustHosts extends Middleware
 {
+    /**
+     * Handle the incoming request.
+     *
+     * Skip host validation for certain routes:
+     * - Terminal auth routes (called by realtime container)
+     * - API routes (use token-based authentication, not host validation)
+     * - Webhook endpoints (use cryptographic signature validation)
+     */
+    public function handle(Request $request, $next)
+    {
+        // Skip host validation for these routes
+        if ($request->is(
+            'terminal/auth',
+            'terminal/auth/ips',
+            'api/*',
+            'webhooks/*'
+        )) {
+            return $next($request);
+        }
+
+        // Skip host validation if no FQDN is configured (initial setup)
+        $fqdnHost = Cache::get('instance_settings_fqdn_host');
+        if ($fqdnHost === '' || $fqdnHost === null) {
+            return $next($request);
+        }
+
+        // For all other routes, use parent's host validation
+        return parent::handle($request, $next);
+    }
+
     /**
      * Get the host patterns that should be trusted.
      *
@@ -13,8 +47,50 @@ class TrustHosts extends Middleware
      */
     public function hosts(): array
     {
-        return [
-            $this->allSubdomainsOfApplicationUrl(),
-        ];
+        $trustedHosts = [];
+
+        // Trust the configured FQDN from InstanceSettings (cached to avoid DB query on every request)
+        // Use empty string as sentinel value instead of null so negative results are cached
+        $fqdnHost = Cache::remember('instance_settings_fqdn_host', 300, function () {
+            try {
+                $settings = InstanceSettings::get();
+                if ($settings && $settings->fqdn) {
+                    $url = Url::fromString($settings->fqdn);
+                    $host = $url->getHost();
+
+                    return $host ?: '';
+                }
+            } catch (\Exception $e) {
+                // If instance settings table doesn't exist yet (during installation),
+                // return empty string (sentinel) so this result is cached
+            }
+
+            return '';
+        });
+
+        // Convert sentinel value back to null for consumption
+        $fqdnHost = $fqdnHost !== '' ? $fqdnHost : null;
+
+        if ($fqdnHost) {
+            $trustedHosts[] = $fqdnHost;
+        }
+
+        // Trust the APP_URL host itself (not just subdomains)
+        $appUrl = config('app.url');
+        if ($appUrl) {
+            try {
+                $appUrlHost = parse_url($appUrl, PHP_URL_HOST);
+                if ($appUrlHost && ! in_array($appUrlHost, $trustedHosts, true)) {
+                    $trustedHosts[] = $appUrlHost;
+                }
+            } catch (\Exception $e) {
+                // Ignore parse errors
+            }
+        }
+
+        // Trust all subdomains of APP_URL as fallback
+        $trustedHosts[] = $this->allSubdomainsOfApplicationUrl();
+
+        return array_filter($trustedHosts);
     }
 }

app/Jobs/ApplicationPullRequestUpdateJob.php

@@ -35,21 +35,25 @@ class ApplicationPullRequestUpdateJob implements ShouldBeEncrypted, ShouldQueue
             if ($this->application->is_public_repository()) {
                 return;
             }
+
+            $serviceName = $this->application->name;
+
             if ($this->status === ProcessStatus::CLOSED) {
                 $this->delete_comment();
 
                 return;
-            } elseif ($this->status === ProcessStatus::IN_PROGRESS) {
-                $this->body = "The preview deployment is in progress. 🟡\n\n";
-            } elseif ($this->status === ProcessStatus::FINISHED) {
-                $this->body = "The preview deployment is ready. 🟢\n\n";
-                if ($this->preview->fqdn) {
-                    $this->body .= "[Open Preview]({$this->preview->fqdn}) | ";
-                }
-            } elseif ($this->status === ProcessStatus::ERROR) {
-                $this->body = "The preview deployment failed. 🔴\n\n";
             }
-            $this->build_logs_url = base_url()."/project/{$this->application->environment->project->uuid}/{$this->application->environment->name}/application/{$this->application->uuid}/deployment/{$this->deployment_uuid}";
+
+            match ($this->status) {
+                ProcessStatus::QUEUED => $this->body = "The preview deployment for **{$serviceName}** is queued. ⏳\n\n",
+                ProcessStatus::IN_PROGRESS => $this->body = "The preview deployment for **{$serviceName}** is in progress. 🟡\n\n",
+                ProcessStatus::FINISHED => $this->body = "The preview deployment for **{$serviceName}** is ready. 🟢\n\n".($this->preview->fqdn ? "[Open Preview]({$this->preview->fqdn}) | " : ''),
+                ProcessStatus::ERROR => $this->body = "The preview deployment for **{$serviceName}** failed. 🔴\n\n",
+                ProcessStatus::KILLED => $this->body = "The preview deployment for **{$serviceName}** was killed. ⚫\n\n",
+                ProcessStatus::CANCELLED => $this->body = "The preview deployment for **{$serviceName}** was cancelled. 🚫\n\n",
+                ProcessStatus::CLOSED => '', // Already handled above, but included for completeness
+            };
+            $this->build_logs_url = base_url()."/project/{$this->application->environment->project->uuid}/environment/{$this->application->environment->uuid}/application/{$this->application->uuid}/deployment/{$this->deployment_uuid}";
 
             $this->body .= '[Open Build Logs]('.$this->build_logs_url.")\n\n\n";
             $this->body .= 'Last updated at: '.now()->toDateTimeString().' CET';

app/Jobs/DatabaseBackupJob.php

@@ -15,6 +15,7 @@ use App\Models\StandalonePostgresql;
 use App\Models\Team;
 use App\Notifications\Database\BackupFailed;
 use App\Notifications\Database\BackupSuccess;
+use App\Notifications\Database\BackupSuccessWithS3Warning;
 use Carbon\Carbon;
 use Illuminate\Bus\Queueable;
 use Illuminate\Contracts\Queue\ShouldBeEncrypted;
@@ -68,7 +69,7 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
 
     public $timeout = 3600;
 
-    public string $backup_log_uuid;
+    public ?string $backup_log_uuid = null;
 
     public function __construct(public ScheduledDatabaseBackup $backup)
     {
@@ -298,6 +299,10 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
                 } while ($exists);
 
                 $size = 0;
+                $localBackupSucceeded = false;
+                $s3UploadError = null;
+
+                // Step 1: Create local backup
                 try {
                     if (str($databaseType)->contains('postgres')) {
                         $this->backup_file = "/pg-dump-$database-".Carbon::now()->timestamp.'.dmp';
@@ -310,6 +315,7 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
                             'database_name' => $database,
                             'filename' => $this->backup_location,
                             'scheduled_database_backup_id' => $this->backup->id,
+                            'local_storage_deleted' => false,
                         ]);
                         $this->backup_standalone_postgresql($database);
                     } elseif (str($databaseType)->contains('mongo')) {
@@ -330,6 +336,7 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
                             'database_name' => $databaseName,
                             'filename' => $this->backup_location,
                             'scheduled_database_backup_id' => $this->backup->id,
+                            'local_storage_deleted' => false,
                         ]);
                         $this->backup_standalone_mongodb($database);
                     } elseif (str($databaseType)->contains('mysql')) {
@@ -343,6 +350,7 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
                             'database_name' => $database,
                             'filename' => $this->backup_location,
                             'scheduled_database_backup_id' => $this->backup->id,
+                            'local_storage_deleted' => false,
                         ]);
                         $this->backup_standalone_mysql($database);
                     } elseif (str($databaseType)->contains('mariadb')) {
@@ -356,56 +364,77 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
                             'database_name' => $database,
                             'filename' => $this->backup_location,
                             'scheduled_database_backup_id' => $this->backup->id,
+                            'local_storage_deleted' => false,
                         ]);
                         $this->backup_standalone_mariadb($database);
                     } else {
                         throw new \Exception('Unsupported database type');
                     }
+
                     $size = $this->calculate_size();
-                    if ($this->backup->save_s3) {
+
+                    // Verify local backup succeeded
+                    if ($size > 0) {
+                        $localBackupSucceeded = true;
+                    } else {
+                        throw new \Exception('Local backup file is empty or was not created');
+                    }
+                } catch (\Throwable $e) {
+                    // Local backup failed
+                    if ($this->backup_log) {
+                        $this->backup_log->update([
+                            'status' => 'failed',
+                            'message' => $this->error_output ?? $this->backup_output ?? $e->getMessage(),
+                            'size' => $size,
+                            'filename' => null,
+                            's3_uploaded' => null,
+                        ]);
+                    }
+                    $this->team?->notify(new BackupFailed($this->backup, $this->database, $this->error_output ?? $this->backup_output ?? $e->getMessage(), $database));
+
+                    continue;
+                }
+
+                // Step 2: Upload to S3 if enabled (independent of local backup)
+                $localStorageDeleted = false;
+                if ($this->backup->save_s3 && $localBackupSucceeded) {
+                    try {
                         $this->upload_to_s3();
 
                         // If local backup is disabled, delete the local file immediately after S3 upload
                         if ($this->backup->disable_local_backup) {
                             deleteBackupsLocally($this->backup_location, $this->server);
+                            $localStorageDeleted = true;
                         }
+                    } catch (\Throwable $e) {
+                        // S3 upload failed but local backup succeeded
+                        $s3UploadError = $e->getMessage();
                     }
+                }
 
-                    $this->team->notify(new BackupSuccess($this->backup, $this->database, $database));
+                // Step 3: Update status and send notifications based on results
+                if ($localBackupSucceeded) {
+                    $message = $this->backup_output;
+
+                    if ($s3UploadError) {
+                        $message = $message
+                            ? $message."\n\nWarning: S3 upload failed: ".$s3UploadError
+                            : 'Warning: S3 upload failed: '.$s3UploadError;
+                    }
 
                     $this->backup_log->update([
                         'status' => 'success',
-                        'message' => $this->backup_output,
+                        'message' => $message,
                         'size' => $size,
+                        's3_uploaded' => $this->backup->save_s3 ? $this->s3_uploaded : null,
+                        'local_storage_deleted' => $localStorageDeleted,
                     ]);
-                } catch (\Throwable $e) {
-                    // Check if backup actually failed or if it's just a post-backup issue
-                    $actualBackupFailed = ! $this->s3_uploaded && $this->backup->save_s3;
 
-                    if ($actualBackupFailed || $size === 0) {
-                        // Real backup failure
-                        if ($this->backup_log) {
-                            $this->backup_log->update([
-                                'status' => 'failed',
-                                'message' => $this->error_output ?? $this->backup_output ?? $e->getMessage(),
-                                'size' => $size,
-                                'filename' => null,
-                            ]);
-                        }
-                        $this->team?->notify(new BackupFailed($this->backup, $this->database, $this->error_output ?? $this->backup_output ?? $e->getMessage(), $database));
+                    // Send appropriate notification
+                    if ($s3UploadError) {
+                        $this->team->notify(new BackupSuccessWithS3Warning($this->backup, $this->database, $database, $s3UploadError));
                     } else {
-                        // Backup succeeded but post-processing failed (cleanup, notification, etc.)
-                        if ($this->backup_log) {
-                            $this->backup_log->update([
-                                'status' => 'success',
-                                'message' => $this->backup_output ? $this->backup_output."\nWarning: Post-backup cleanup encountered an issue: ".$e->getMessage() : 'Warning: '.$e->getMessage(),
-                                'size' => $size,
-                            ]);
-                        }
-                        // Send success notification since the backup itself succeeded
                         $this->team->notify(new BackupSuccess($this->backup, $this->database, $database));
-                        // Log the post-backup issue
-                        ray('Post-backup operation failed but backup was successful: '.$e->getMessage());
                     }
                 }
             }
@@ -591,24 +620,24 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
 
             $fullImageName = $this->getFullImageName();
 
-            $containerExists = instant_remote_process(["docker ps -a -q -f name=backup-of-{$this->backup->uuid}"], $this->server, false);
+            $containerExists = instant_remote_process(["docker ps -a -q -f name=backup-of-{$this->backup_log_uuid}"], $this->server, false);
             if (filled($containerExists)) {
-                instant_remote_process(["docker rm -f backup-of-{$this->backup->uuid}"], $this->server, false);
+                instant_remote_process(["docker rm -f backup-of-{$this->backup_log_uuid}"], $this->server, false);
             }
 
             if (isDev()) {
                 if ($this->database->name === 'coolify-db') {
                     $backup_location_from = '/var/lib/docker/volumes/coolify_dev_backups_data/_data/coolify/coolify-db-'.$this->server->ip.$this->backup_file;
-                    $commands[] = "docker run -d --network {$network} --name backup-of-{$this->backup->uuid} --rm -v $backup_location_from:$this->backup_location:ro {$fullImageName}";
+                    $commands[] = "docker run -d --network {$network} --name backup-of-{$this->backup_log_uuid} --rm -v $backup_location_from:$this->backup_location:ro {$fullImageName}";
                 } else {
                     $backup_location_from = '/var/lib/docker/volumes/coolify_dev_backups_data/_data/databases/'.str($this->team->name)->slug().'-'.$this->team->id.'/'.$this->directory_name.$this->backup_file;
-                    $commands[] = "docker run -d --network {$network} --name backup-of-{$this->backup->uuid} --rm -v $backup_location_from:$this->backup_location:ro {$fullImageName}";
+                    $commands[] = "docker run -d --network {$network} --name backup-of-{$this->backup_log_uuid} --rm -v $backup_location_from:$this->backup_location:ro {$fullImageName}";
                 }
             } else {
-                $commands[] = "docker run -d --network {$network} --name backup-of-{$this->backup->uuid} --rm -v $this->backup_location:$this->backup_location:ro {$fullImageName}";
+                $commands[] = "docker run -d --network {$network} --name backup-of-{$this->backup_log_uuid} --rm -v $this->backup_location:$this->backup_location:ro {$fullImageName}";
             }
-            $commands[] = "docker exec backup-of-{$this->backup->uuid} mc alias set temporary {$endpoint} {$key} \"{$secret}\"";
-            $commands[] = "docker exec backup-of-{$this->backup->uuid} mc cp $this->backup_location temporary/$bucket{$this->backup_dir}/";
+            $commands[] = "docker exec backup-of-{$this->backup_log_uuid} mc alias set temporary {$endpoint} {$key} \"{$secret}\"";
+            $commands[] = "docker exec backup-of-{$this->backup_log_uuid} mc cp $this->backup_location temporary/$bucket{$this->backup_dir}/";
             instant_remote_process($commands, $this->server);
 
             $this->s3_uploaded = true;
@@ -617,7 +646,7 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
             $this->add_to_error_output($e->getMessage());
             throw $e;
         } finally {
-            $command = "docker rm -f backup-of-{$this->backup->uuid}";
+            $command = "docker rm -f backup-of-{$this->backup_log_uuid}";
             instant_remote_process([$command], $this->server);
         }
     }

app/Jobs/RegenerateSslCertJob.php

@@ -45,7 +45,7 @@ class RegenerateSslCertJob implements ShouldQueue
 
         $query->cursor()->each(function ($certificate) use ($regenerated) {
             try {
-                $caCert = SslCertificate::where('server_id', $certificate->server_id)
+                $caCert = $certificate->server->sslCertificates()
                     ->where('is_ca_certificate', true)
                     ->first();
 

app/Jobs/ScheduledJobManager.php

@@ -52,7 +52,8 @@ class ScheduledJobManager implements ShouldQueue
     {
         return [
             (new WithoutOverlapping('scheduled-job-manager'))
-                ->releaseAfter(60), // Release the lock after 60 seconds if job fails
+                ->expireAfter(60)   // Lock expires after 1 minute to prevent stale locks
+                ->dontRelease(),    // Don't re-queue on lock conflict
         ];
     }
 

app/Jobs/SendWebhookJob.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Jobs;
+
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldBeEncrypted;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Http;
+
+class SendWebhookJob implements ShouldBeEncrypted, ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    /**
+     * The number of times the job may be attempted.
+     *
+     * @var int
+     */
+    public $tries = 5;
+
+    public $backoff = 10;
+
+    /**
+     * The maximum number of unhandled exceptions to allow before failing.
+     */
+    public int $maxExceptions = 5;
+
+    public function __construct(
+        public array $payload,
+        public string $webhookUrl
+    ) {
+        $this->onQueue('high');
+    }
+
+    /**
+     * Execute the job.
+     */
+    public function handle(): void
+    {
+        if (isDev()) {
+            ray('Sending webhook notification', [
+                'url' => $this->webhookUrl,
+                'payload' => $this->payload,
+            ]);
+        }
+
+        $response = Http::post($this->webhookUrl, $this->payload);
+
+        if (isDev()) {
+            ray('Webhook response', [
+                'status' => $response->status(),
+                'body' => $response->body(),
+                'successful' => $response->successful(),
+            ]);
+        }
+    }
+}

app/Jobs/ServerConnectionCheckJob.php

@@ -54,6 +54,11 @@ class ServerConnectionCheckJob implements ShouldBeEncrypted, ShouldQueue
                 return;
             }
 
+            // Check Hetzner server status if applicable
+            if ($this->server->hetzner_server_id && $this->server->cloudProviderToken) {
+                $this->checkHetznerStatus();
+            }
+
             // Temporarily disable mux if requested
             if ($this->disableMux) {
                 $this->disableSshMux();
@@ -86,6 +91,11 @@ class ServerConnectionCheckJob implements ShouldBeEncrypted, ShouldQueue
             ]);
 
         } catch (\Throwable $e) {
+
+            Log::error('ServerConnectionCheckJob failed', [
+                'error' => $e->getMessage(),
+                'server_id' => $this->server->id,
+            ]);
             $this->server->settings->update([
                 'is_reachable' => false,
                 'is_usable' => false,
@@ -95,6 +105,30 @@ class ServerConnectionCheckJob implements ShouldBeEncrypted, ShouldQueue
         }
     }
 
+    private function checkHetznerStatus(): void
+    {
+        try {
+            $hetznerService = new \App\Services\HetznerService($this->server->cloudProviderToken->token);
+            $serverData = $hetznerService->getServer($this->server->hetzner_server_id);
+            $status = $serverData['status'] ?? null;
+
+        } catch (\Throwable $e) {
+            Log::debug('ServerConnectionCheck: Hetzner status check failed', [
+                'server_id' => $this->server->id,
+                'error' => $e->getMessage(),
+            ]);
+        }
+        if ($this->server->hetzner_server_status !== $status) {
+            $this->server->update(['hetzner_server_status' => $status]);
+            $this->server->hetzner_server_status = $status;
+            if ($status === 'off') {
+                ray('Server is powered off, marking as unreachable');
+                throw new \Exception('Server is powered off');
+            }
+        }
+
+    }
+
     private function checkConnection(): bool
     {
         try {

app/Jobs/ValidateAndInstallServerJob.php

@@ -0,0 +1,162 @@
+<?php
+
+namespace App\Jobs;
+
+use App\Actions\Proxy\CheckProxy;
+use App\Actions\Proxy\StartProxy;
+use App\Events\ServerReachabilityChanged;
+use App\Events\ServerValidated;
+use App\Models\Server;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Log;
+
+class ValidateAndInstallServerJob implements ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    public $timeout = 600; // 10 minutes
+
+    public int $maxTries = 3;
+
+    public function __construct(
+        public Server $server,
+        public int $numberOfTries = 0
+    ) {
+        $this->onQueue('high');
+    }
+
+    public function handle(): void
+    {
+        try {
+            // Mark validation as in progress
+            $this->server->update(['is_validating' => true]);
+
+            Log::info('ValidateAndInstallServer: Starting validation', [
+                'server_id' => $this->server->id,
+                'server_name' => $this->server->name,
+                'attempt' => $this->numberOfTries + 1,
+            ]);
+
+            // Validate connection
+            ['uptime' => $uptime, 'error' => $error] = $this->server->validateConnection();
+            if (! $uptime) {
+                $errorMessage = 'Server is not reachable. Please validate your configuration and connection.<br>Check this <a target="_blank" class="underline" href="https://coolify.io/docs/knowledge-base/server/openssh">documentation</a> for further help. <br><br>Error: '.$error;
+                $this->server->update([
+                    'validation_logs' => $errorMessage,
+                    'is_validating' => false,
+                ]);
+                Log::error('ValidateAndInstallServer: Server not reachable', [
+                    'server_id' => $this->server->id,
+                    'error' => $error,
+                ]);
+
+                return;
+            }
+
+            // Validate OS
+            $supportedOsType = $this->server->validateOS();
+            if (! $supportedOsType) {
+                $errorMessage = 'Server OS type is not supported. Please install Docker manually before continuing: <a target="_blank" class="underline" href="https://docs.docker.com/engine/install/#server">documentation</a>.';
+                $this->server->update([
+                    'validation_logs' => $errorMessage,
+                    'is_validating' => false,
+                ]);
+                Log::error('ValidateAndInstallServer: OS not supported', [
+                    'server_id' => $this->server->id,
+                ]);
+
+                return;
+            }
+
+            // Check if Docker is installed
+            $dockerInstalled = $this->server->validateDockerEngine();
+            $dockerComposeInstalled = $this->server->validateDockerCompose();
+
+            if (! $dockerInstalled || ! $dockerComposeInstalled) {
+                // Try to install Docker
+                if ($this->numberOfTries >= $this->maxTries) {
+                    $errorMessage = 'Docker Engine could not be installed after '.$this->maxTries.' attempts. Please install Docker manually before continuing: <a target="_blank" class="underline" href="https://docs.docker.com/engine/install/#server">documentation</a>.';
+                    $this->server->update([
+                        'validation_logs' => $errorMessage,
+                        'is_validating' => false,
+                    ]);
+                    Log::error('ValidateAndInstallServer: Docker installation failed after max tries', [
+                        'server_id' => $this->server->id,
+                        'attempts' => $this->numberOfTries,
+                    ]);
+
+                    return;
+                }
+
+                Log::info('ValidateAndInstallServer: Installing Docker', [
+                    'server_id' => $this->server->id,
+                    'attempt' => $this->numberOfTries + 1,
+                ]);
+
+                // Install Docker
+                $this->server->installDocker();
+
+                // Retry validation after installation
+                self::dispatch($this->server, $this->numberOfTries + 1)->delay(now()->addSeconds(30));
+
+                return;
+            }
+
+            // Validate Docker version
+            $dockerVersion = $this->server->validateDockerEngineVersion();
+            if (! $dockerVersion) {
+                $requiredDockerVersion = str(config('constants.docker.minimum_required_version'))->before('.');
+                $errorMessage = 'Minimum Docker Engine version '.$requiredDockerVersion.' is not installed. Please install Docker manually before continuing: <a target="_blank" class="underline" href="https://docs.docker.com/engine/install/#server">documentation</a>.';
+                $this->server->update([
+                    'validation_logs' => $errorMessage,
+                    'is_validating' => false,
+                ]);
+                Log::error('ValidateAndInstallServer: Docker version not sufficient', [
+                    'server_id' => $this->server->id,
+                ]);
+
+                return;
+            }
+
+            // Validation successful!
+            Log::info('ValidateAndInstallServer: Validation successful', [
+                'server_id' => $this->server->id,
+                'server_name' => $this->server->name,
+            ]);
+
+            // Start proxy if needed
+            if (! $this->server->isBuildServer()) {
+                $proxyShouldRun = CheckProxy::run($this->server, true);
+                if ($proxyShouldRun) {
+                    StartProxy::dispatch($this->server);
+                }
+            }
+
+            // Mark validation as complete
+            $this->server->update(['is_validating' => false]);
+
+            // Refresh server to get latest state
+            $this->server->refresh();
+
+            // Broadcast events to update UI
+            ServerValidated::dispatch($this->server->team_id, $this->server->uuid);
+            ServerReachabilityChanged::dispatch($this->server);
+
+        } catch (\Throwable $e) {
+            Log::error('ValidateAndInstallServer: Exception occurred', [
+                'server_id' => $this->server->id,
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString(),
+            ]);
+
+            $this->server->update([
+                'validation_logs' => 'An error occurred during validation: '.$e->getMessage(),
+                'is_validating' => false,
+            ]);
+        }
+    }
+}

app/Livewire/Boarding/Index.php

@@ -16,14 +16,18 @@ class Index extends Component
 {
     protected $listeners = ['refreshBoardingIndex' => 'validateServer'];
 
+    #[\Livewire\Attributes\Url(as: 'step', history: true)]
     public string $currentState = 'welcome';
 
+    #[\Livewire\Attributes\Url(keep: true)]
     public ?string $selectedServerType = null;
 
     public ?Collection $privateKeys = null;
 
+    #[\Livewire\Attributes\Url(keep: true)]
     public ?int $selectedExistingPrivateKey = null;
 
+    #[\Livewire\Attributes\Url(keep: true)]
     public ?string $privateKeyType = null;
 
     public ?string $privateKey = null;
@@ -38,6 +42,7 @@ class Index extends Component
 
     public ?Collection $servers = null;
 
+    #[\Livewire\Attributes\Url(keep: true)]
     public ?int $selectedExistingServer = null;
 
     public ?string $remoteServerName = null;
@@ -58,6 +63,7 @@ class Index extends Component
 
     public Collection $projects;
 
+    #[\Livewire\Attributes\Url(keep: true)]
     public ?int $selectedProject = null;
 
     public ?Project $createdProject = null;
@@ -79,17 +85,68 @@ class Index extends Component
         $this->minDockerVersion = str(config('constants.docker.minimum_required_version'))->before('.');
         $this->privateKeyName = generate_random_name();
         $this->remoteServerName = generate_random_name();
-        if (isDev()) {
-            $this->privateKey = '-----BEGIN OPENSSH PRIVATE KEY-----
-b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
-QyNTUxOQAAACBbhpqHhqv6aI67Mj9abM3DVbmcfYhZAhC7ca4d9UCevAAAAJi/QySHv0Mk
-hwAAAAtzc2gtZWQyNTUxOQAAACBbhpqHhqv6aI67Mj9abM3DVbmcfYhZAhC7ca4d9UCevA
-AAAECBQw4jg1WRT2IGHMncCiZhURCts2s24HoDS0thHnnRKVuGmoeGq/pojrsyP1pszcNV
-uZx9iFkCELtxrh31QJ68AAAAEXNhaWxANzZmZjY2ZDJlMmRkAQIDBA==
------END OPENSSH PRIVATE KEY-----';
-            $this->privateKeyDescription = 'Created by Coolify';
-            $this->remoteServerDescription = 'Created by Coolify';
-            $this->remoteServerHost = 'coolify-testing-host';
+
+        // Initialize collections to avoid null errors
+        if ($this->privateKeys === null) {
+            $this->privateKeys = collect();
+        }
+        if ($this->servers === null) {
+            $this->servers = collect();
+        }
+        if (! isset($this->projects)) {
+            $this->projects = collect();
+        }
+
+        // Restore state when coming from URL with query params
+        if ($this->selectedServerType === 'localhost' && $this->selectedExistingServer === 0) {
+            $this->createdServer = Server::find(0);
+            if ($this->createdServer) {
+                $this->serverPublicKey = $this->createdServer->privateKey->getPublicKey();
+            }
+        }
+
+        if ($this->selectedServerType === 'remote') {
+            if ($this->privateKeys->isEmpty()) {
+                $this->privateKeys = PrivateKey::ownedAndOnlySShKeys(['name'])->where('id', '!=', 0)->get();
+            }
+            if ($this->servers->isEmpty()) {
+                $this->servers = Server::ownedByCurrentTeam(['name'])->where('id', '!=', 0)->get();
+            }
+
+            if ($this->selectedExistingServer) {
+                $this->createdServer = Server::find($this->selectedExistingServer);
+                if ($this->createdServer) {
+                    $this->serverPublicKey = $this->createdServer->privateKey->getPublicKey();
+                    $this->updateServerDetails();
+                }
+            }
+
+            if ($this->selectedExistingPrivateKey) {
+                $this->createdPrivateKey = PrivateKey::where('team_id', currentTeam()->id)
+                    ->where('id', $this->selectedExistingPrivateKey)
+                    ->first();
+                if ($this->createdPrivateKey) {
+                    $this->privateKey = $this->createdPrivateKey->private_key;
+                    $this->publicKey = $this->createdPrivateKey->getPublicKey();
+                }
+            }
+
+            // Auto-regenerate key pair for "Generate with Coolify" mode on page refresh
+            if ($this->privateKeyType === 'create' && empty($this->privateKey)) {
+                $this->createNewPrivateKey();
+            }
+        }
+
+        if ($this->selectedProject) {
+            $this->createdProject = Project::find($this->selectedProject);
+            if (! $this->createdProject) {
+                $this->projects = Project::ownedByCurrentTeam(['name'])->get();
+            }
+        }
+
+        // Load projects when on create-project state (for page refresh)
+        if ($this->currentState === 'create-project' && $this->projects->isEmpty()) {
+            $this->projects = Project::ownedByCurrentTeam(['name'])->get();
         }
     }
 
@@ -129,41 +186,16 @@ uZx9iFkCELtxrh31QJ68AAAAEXNhaWxANzZmZjY2ZDJlMmRkAQIDBA==
 
             return $this->validateServer('localhost');
         } elseif ($this->selectedServerType === 'remote') {
-            if (isDev()) {
-                $this->privateKeys = PrivateKey::ownedByCurrentTeam(['name'])->get();
-            } else {
-                $this->privateKeys = PrivateKey::ownedByCurrentTeam(['name'])->where('id', '!=', 0)->get();
-            }
+            $this->privateKeys = PrivateKey::ownedAndOnlySShKeys(['name'])->where('id', '!=', 0)->get();
+            // Auto-select first key if available for better UX
             if ($this->privateKeys->count() > 0) {
                 $this->selectedExistingPrivateKey = $this->privateKeys->first()->id;
             }
-            $this->servers = Server::ownedByCurrentTeam(['name'])->where('id', '!=', 0)->get();
-            if ($this->servers->count() > 0) {
-                $this->selectedExistingServer = $this->servers->first()->id;
-                $this->updateServerDetails();
-                $this->currentState = 'select-existing-server';
-
-                return;
-            }
+            // Onboarding always creates new servers, skip existing server selection
             $this->currentState = 'private-key';
         }
     }
 
-    public function selectExistingServer()
-    {
-        $this->createdServer = Server::find($this->selectedExistingServer);
-        if (! $this->createdServer) {
-            $this->dispatch('error', 'Server is not found.');
-            $this->currentState = 'private-key';
-
-            return;
-        }
-        $this->selectedExistingPrivateKey = $this->createdServer->privateKey->id;
-        $this->serverPublicKey = $this->createdServer->privateKey->getPublicKey();
-        $this->updateServerDetails();
-        $this->currentState = 'validate-server';
-    }
-
     private function updateServerDetails()
     {
         if ($this->createdServer) {
@@ -181,7 +213,7 @@ uZx9iFkCELtxrh31QJ68AAAAEXNhaWxANzZmZjY2ZDJlMmRkAQIDBA==
     public function selectExistingPrivateKey()
     {
         if (is_null($this->selectedExistingPrivateKey)) {
-            $this->restartBoarding();
+            $this->dispatch('error', 'Please select a private key.');
 
             return;
         }
@@ -202,6 +234,9 @@ uZx9iFkCELtxrh31QJ68AAAAEXNhaWxANzZmZjY2ZDJlMmRkAQIDBA==
         $this->privateKeyType = $type;
         if ($type === 'create') {
             $this->createNewPrivateKey();
+        } else {
+            $this->privateKey = null;
+            $this->publicKey = null;
         }
         $this->currentState = 'create-private-key';
     }

app/Livewire/Concerns/SynchronizesModelData.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Livewire\Concerns;
+
+trait SynchronizesModelData
+{
+    /**
+     * Define the mapping between component properties and model keys.
+     *
+     * @return array<string, string> Array mapping property names to model keys (e.g., ['content' => 'fileStorage.content'])
+     */
+    abstract protected function getModelBindings(): array;
+
+    /**
+     * Synchronize component properties TO the model.
+     * Copies values from component properties to the model.
+     */
+    protected function syncToModel(): void
+    {
+        foreach ($this->getModelBindings() as $property => $modelKey) {
+            data_set($this, $modelKey, $this->{$property});
+        }
+    }
+
+    /**
+     * Synchronize component properties FROM the model.
+     * Copies values from the model to component properties.
+     */
+    protected function syncFromModel(): void
+    {
+        foreach ($this->getModelBindings() as $property => $modelKey) {
+            $this->{$property} = data_get($this, $modelKey);
+        }
+    }
+}

app/Livewire/Dashboard.php

@@ -2,63 +2,25 @@
 
 namespace App\Livewire;
 
-use App\Models\Application;
-use App\Models\ApplicationDeploymentQueue;
 use App\Models\PrivateKey;
 use App\Models\Project;
 use App\Models\Server;
 use Illuminate\Support\Collection;
-use Illuminate\Support\Facades\Artisan;
 use Livewire\Component;
 
 class Dashboard extends Component
 {
-    public $projects = [];
+    public Collection $projects;
 
     public Collection $servers;
 
     public Collection $privateKeys;
 
-    public array $deploymentsPerServer = [];
-
     public function mount()
     {
         $this->privateKeys = PrivateKey::ownedByCurrentTeam()->get();
         $this->servers = Server::ownedByCurrentTeam()->get();
         $this->projects = Project::ownedByCurrentTeam()->get();
-        $this->loadDeployments();
-    }
-
-    public function cleanupQueue()
-    {
-        try {
-            $this->authorize('cleanupDeploymentQueue', Application::class);
-        } catch (\Illuminate\Auth\Access\AuthorizationException $e) {
-            return handleError($e, $this);
-        }
-
-        Artisan::queue('cleanup:deployment-queue', [
-            '--team-id' => currentTeam()->id,
-        ]);
-    }
-
-    public function loadDeployments()
-    {
-        $this->deploymentsPerServer = ApplicationDeploymentQueue::whereIn('status', ['in_progress', 'queued'])->whereIn('server_id', $this->servers->pluck('id'))->get([
-            'id',
-            'application_id',
-            'application_name',
-            'deployment_url',
-            'pull_request_id',
-            'server_name',
-            'server_id',
-            'status',
-        ])->sortBy('id')->groupBy('server_name')->toArray();
-    }
-
-    public function navigateToProject($projectUuid)
-    {
-        return $this->redirect(collect($this->projects)->firstWhere('uuid', $projectUuid)->navigateTo(), navigate: false);
     }
 
     public function render()

app/Livewire/DeploymentsIndicator.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Livewire;
+
+use App\Models\ApplicationDeploymentQueue;
+use App\Models\Server;
+use Livewire\Attributes\Computed;
+use Livewire\Component;
+
+class DeploymentsIndicator extends Component
+{
+    public bool $expanded = false;
+
+    #[Computed]
+    public function deployments()
+    {
+        $servers = Server::ownedByCurrentTeam()->get();
+
+        return ApplicationDeploymentQueue::with(['application.environment.project'])
+            ->whereIn('status', ['in_progress', 'queued'])
+            ->whereIn('server_id', $servers->pluck('id'))
+            ->orderBy('id')
+            ->get([
+                'id',
+                'application_id',
+                'application_name',
+                'deployment_url',
+                'pull_request_id',
+                'server_name',
+                'server_id',
+                'status',
+            ]);
+    }
+
+    #[Computed]
+    public function deploymentCount()
+    {
+        return $this->deployments->count();
+    }
+
+    public function toggleExpanded()
+    {
+        $this->expanded = ! $this->expanded;
+    }
+
+    public function render()
+    {
+        return view('livewire.deployments-indicator');
+    }
+}

app/Livewire/MonacoEditor.php

@@ -25,6 +25,7 @@ class MonacoEditor extends Component
         public bool $readonly,
         public bool $allowTab,
         public bool $spellcheck,
+        public bool $autofocus,
         public ?string $helper,
         public bool $realtimeValidation,
         public bool $allowToPeak,

app/Livewire/Notifications/Webhook.php

@@ -0,0 +1,196 @@
+<?php
+
+namespace App\Livewire\Notifications;
+
+use App\Models\Team;
+use App\Models\WebhookNotificationSettings;
+use App\Notifications\Test;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Livewire\Attributes\Validate;
+use Livewire\Component;
+
+class Webhook extends Component
+{
+    use AuthorizesRequests;
+
+    public Team $team;
+
+    public WebhookNotificationSettings $settings;
+
+    #[Validate(['boolean'])]
+    public bool $webhookEnabled = false;
+
+    #[Validate(['url', 'nullable'])]
+    public ?string $webhookUrl = null;
+
+    #[Validate(['boolean'])]
+    public bool $deploymentSuccessWebhookNotifications = false;
+
+    #[Validate(['boolean'])]
+    public bool $deploymentFailureWebhookNotifications = true;
+
+    #[Validate(['boolean'])]
+    public bool $statusChangeWebhookNotifications = false;
+
+    #[Validate(['boolean'])]
+    public bool $backupSuccessWebhookNotifications = false;
+
+    #[Validate(['boolean'])]
+    public bool $backupFailureWebhookNotifications = true;
+
+    #[Validate(['boolean'])]
+    public bool $scheduledTaskSuccessWebhookNotifications = false;
+
+    #[Validate(['boolean'])]
+    public bool $scheduledTaskFailureWebhookNotifications = true;
+
+    #[Validate(['boolean'])]
+    public bool $dockerCleanupSuccessWebhookNotifications = false;
+
+    #[Validate(['boolean'])]
+    public bool $dockerCleanupFailureWebhookNotifications = true;
+
+    #[Validate(['boolean'])]
+    public bool $serverDiskUsageWebhookNotifications = true;
+
+    #[Validate(['boolean'])]
+    public bool $serverReachableWebhookNotifications = false;
+
+    #[Validate(['boolean'])]
+    public bool $serverUnreachableWebhookNotifications = true;
+
+    #[Validate(['boolean'])]
+    public bool $serverPatchWebhookNotifications = false;
+
+    public function mount()
+    {
+        try {
+            $this->team = auth()->user()->currentTeam();
+            $this->settings = $this->team->webhookNotificationSettings;
+            $this->authorize('view', $this->settings);
+            $this->syncData();
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function syncData(bool $toModel = false)
+    {
+        if ($toModel) {
+            $this->validate();
+            $this->authorize('update', $this->settings);
+            $this->settings->webhook_enabled = $this->webhookEnabled;
+            $this->settings->webhook_url = $this->webhookUrl;
+
+            $this->settings->deployment_success_webhook_notifications = $this->deploymentSuccessWebhookNotifications;
+            $this->settings->deployment_failure_webhook_notifications = $this->deploymentFailureWebhookNotifications;
+            $this->settings->status_change_webhook_notifications = $this->statusChangeWebhookNotifications;
+            $this->settings->backup_success_webhook_notifications = $this->backupSuccessWebhookNotifications;
+            $this->settings->backup_failure_webhook_notifications = $this->backupFailureWebhookNotifications;
+            $this->settings->scheduled_task_success_webhook_notifications = $this->scheduledTaskSuccessWebhookNotifications;
+            $this->settings->scheduled_task_failure_webhook_notifications = $this->scheduledTaskFailureWebhookNotifications;
+            $this->settings->docker_cleanup_success_webhook_notifications = $this->dockerCleanupSuccessWebhookNotifications;
+            $this->settings->docker_cleanup_failure_webhook_notifications = $this->dockerCleanupFailureWebhookNotifications;
+            $this->settings->server_disk_usage_webhook_notifications = $this->serverDiskUsageWebhookNotifications;
+            $this->settings->server_reachable_webhook_notifications = $this->serverReachableWebhookNotifications;
+            $this->settings->server_unreachable_webhook_notifications = $this->serverUnreachableWebhookNotifications;
+            $this->settings->server_patch_webhook_notifications = $this->serverPatchWebhookNotifications;
+
+            $this->settings->save();
+            refreshSession();
+        } else {
+            $this->webhookEnabled = $this->settings->webhook_enabled;
+            $this->webhookUrl = $this->settings->webhook_url;
+
+            $this->deploymentSuccessWebhookNotifications = $this->settings->deployment_success_webhook_notifications;
+            $this->deploymentFailureWebhookNotifications = $this->settings->deployment_failure_webhook_notifications;
+            $this->statusChangeWebhookNotifications = $this->settings->status_change_webhook_notifications;
+            $this->backupSuccessWebhookNotifications = $this->settings->backup_success_webhook_notifications;
+            $this->backupFailureWebhookNotifications = $this->settings->backup_failure_webhook_notifications;
+            $this->scheduledTaskSuccessWebhookNotifications = $this->settings->scheduled_task_success_webhook_notifications;
+            $this->scheduledTaskFailureWebhookNotifications = $this->settings->scheduled_task_failure_webhook_notifications;
+            $this->dockerCleanupSuccessWebhookNotifications = $this->settings->docker_cleanup_success_webhook_notifications;
+            $this->dockerCleanupFailureWebhookNotifications = $this->settings->docker_cleanup_failure_webhook_notifications;
+            $this->serverDiskUsageWebhookNotifications = $this->settings->server_disk_usage_webhook_notifications;
+            $this->serverReachableWebhookNotifications = $this->settings->server_reachable_webhook_notifications;
+            $this->serverUnreachableWebhookNotifications = $this->settings->server_unreachable_webhook_notifications;
+            $this->serverPatchWebhookNotifications = $this->settings->server_patch_webhook_notifications;
+        }
+    }
+
+    public function instantSaveWebhookEnabled()
+    {
+        try {
+            $original = $this->webhookEnabled;
+            $this->validate([
+                'webhookUrl' => 'required',
+            ], [
+                'webhookUrl.required' => 'Webhook URL is required.',
+            ]);
+            $this->saveModel();
+        } catch (\Throwable $e) {
+            $this->webhookEnabled = $original;
+
+            return handleError($e, $this);
+        }
+    }
+
+    public function instantSave()
+    {
+        try {
+            $this->syncData(true);
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function submit()
+    {
+        try {
+            $this->resetErrorBag();
+            $this->syncData(true);
+            $this->saveModel();
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function saveModel()
+    {
+        $this->syncData(true);
+        refreshSession();
+
+        if (isDev()) {
+            ray('Webhook settings saved', [
+                'webhook_enabled' => $this->settings->webhook_enabled,
+                'webhook_url' => $this->settings->webhook_url,
+            ]);
+        }
+
+        $this->dispatch('success', 'Settings saved.');
+    }
+
+    public function sendTestNotification()
+    {
+        try {
+            $this->authorize('sendTest', $this->settings);
+
+            if (isDev()) {
+                ray('Sending test webhook notification', [
+                    'team_id' => $this->team->id,
+                    'webhook_url' => $this->settings->webhook_url,
+                ]);
+            }
+
+            $this->team->notify(new Test(channel: 'webhook'));
+            $this->dispatch('success', 'Test notification sent.');
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function render()
+    {
+        return view('livewire.notifications.webhook');
+    }
+}

app/Livewire/Project/AddEmpty.php

@@ -37,7 +37,12 @@ class AddEmpty extends Component
                 'uuid' => (string) new Cuid2,
             ]);
 
-            return redirect()->route('project.show', $project->uuid);
+            $productionEnvironment = $project->environments()->where('name', 'production')->first();
+
+            return redirect()->route('project.resource.index', [
+                'project_uuid' => $project->uuid,
+                'environment_uuid' => $productionEnvironment->uuid,
+            ]);
         } catch (\Throwable $e) {
             return handleError($e, $this);
         }

app/Livewire/Project/Application/DeploymentNavbar.php

@@ -50,6 +50,28 @@ class DeploymentNavbar extends Component
         }
     }
 
+    public function copyLogsToClipboard(): string
+    {
+        $logs = json_decode($this->application_deployment_queue->logs, associative: true, flags: JSON_THROW_ON_ERROR);
+
+        if (! $logs) {
+            return '';
+        }
+
+        $markdown = "# Deployment Logs\n\n";
+        $markdown .= "```\n";
+
+        foreach ($logs as $log) {
+            if (isset($log['output'])) {
+                $markdown .= $log['output']."\n";
+            }
+        }
+
+        $markdown .= "```\n";
+
+        return $markdown;
+    }
+
     public function cancel()
     {
         $deployment_uuid = $this->application_deployment_queue->deployment_uuid;

app/Livewire/Project/Application/General.php

@@ -3,6 +3,7 @@
 namespace App\Livewire\Project\Application;
 
 use App\Actions\Application\GenerateConfig;
+use App\Livewire\Concerns\SynchronizesModelData;
 use App\Models\Application;
 use App\Support\ValidationPatterns;
 use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
@@ -14,6 +15,7 @@ use Visus\Cuid2\Cuid2;
 class General extends Component
 {
     use AuthorizesRequests;
+    use SynchronizesModelData;
 
     public string $applicationId;
 
@@ -23,6 +25,8 @@ class General extends Component
 
     public string $name;
 
+    public ?string $description = null;
+
     public ?string $fqdn = null;
 
     public string $git_repository;
@@ -31,14 +35,82 @@ class General extends Component
 
     public ?string $git_commit_sha = null;
 
+    public ?string $install_command = null;
+
+    public ?string $build_command = null;
+
+    public ?string $start_command = null;
+
     public string $build_pack;
 
+    public string $static_image;
+
+    public string $base_directory;
+
+    public ?string $publish_directory = null;
+
     public ?string $ports_exposes = null;
 
+    public ?string $ports_mappings = null;
+
+    public ?string $custom_network_aliases = null;
+
+    public ?string $dockerfile = null;
+
+    public ?string $dockerfile_location = null;
+
+    public ?string $dockerfile_target_build = null;
+
+    public ?string $docker_registry_image_name = null;
+
+    public ?string $docker_registry_image_tag = null;
+
+    public ?string $docker_compose_location = null;
+
+    public ?string $docker_compose = null;
+
+    public ?string $docker_compose_raw = null;
+
+    public ?string $docker_compose_custom_start_command = null;
+
+    public ?string $docker_compose_custom_build_command = null;
+
+    public ?string $custom_labels = null;
+
+    public ?string $custom_docker_run_options = null;
+
+    public ?string $pre_deployment_command = null;
+
+    public ?string $pre_deployment_command_container = null;
+
+    public ?string $post_deployment_command = null;
+
+    public ?string $post_deployment_command_container = null;
+
+    public ?string $custom_nginx_configuration = null;
+
+    public bool $is_static = false;
+
+    public bool $is_spa = false;
+
+    public bool $is_build_server_enabled = false;
+
     public bool $is_preserve_repository_enabled = false;
 
     public bool $is_container_label_escape_enabled = true;
 
+    public bool $is_container_label_readonly_enabled = false;
+
+    public bool $is_http_basic_auth_enabled = false;
+
+    public ?string $http_basic_auth_username = null;
+
+    public ?string $http_basic_auth_password = null;
+
+    public ?string $watch_paths = null;
+
+    public string $redirect;
+
     public $customLabels;
 
     public bool $labelsChanged = false;
@@ -66,50 +138,50 @@ class General extends Component
     protected function rules(): array
     {
         return [
-            'application.name' => ValidationPatterns::nameRules(),
-            'application.description' => ValidationPatterns::descriptionRules(),
-            'application.fqdn' => 'nullable',
-            'application.git_repository' => 'required',
-            'application.git_branch' => 'required',
-            'application.git_commit_sha' => 'nullable',
-            'application.install_command' => 'nullable',
-            'application.build_command' => 'nullable',
-            'application.start_command' => 'nullable',
-            'application.build_pack' => 'required',
-            'application.static_image' => 'required',
-            'application.base_directory' => 'required',
-            'application.publish_directory' => 'nullable',
-            'application.ports_exposes' => 'required',
-            'application.ports_mappings' => 'nullable',
-            'application.custom_network_aliases' => 'nullable',
-            'application.dockerfile' => 'nullable',
-            'application.docker_registry_image_name' => 'nullable',
-            'application.docker_registry_image_tag' => 'nullable',
-            'application.dockerfile_location' => 'nullable',
-            'application.docker_compose_location' => 'nullable',
-            'application.docker_compose' => 'nullable',
-            'application.docker_compose_raw' => 'nullable',
-            'application.dockerfile_target_build' => 'nullable',
-            'application.docker_compose_custom_start_command' => 'nullable',
-            'application.docker_compose_custom_build_command' => 'nullable',
-            'application.custom_labels' => 'nullable',
-            'application.custom_docker_run_options' => 'nullable',
-            'application.pre_deployment_command' => 'nullable',
-            'application.pre_deployment_command_container' => 'nullable',
-            'application.post_deployment_command' => 'nullable',
-            'application.post_deployment_command_container' => 'nullable',
-            'application.custom_nginx_configuration' => 'nullable',
-            'application.settings.is_static' => 'boolean|required',
-            'application.settings.is_spa' => 'boolean|required',
-            'application.settings.is_build_server_enabled' => 'boolean|required',
-            'application.settings.is_container_label_escape_enabled' => 'boolean|required',
-            'application.settings.is_container_label_readonly_enabled' => 'boolean|required',
-            'application.settings.is_preserve_repository_enabled' => 'boolean|required',
-            'application.is_http_basic_auth_enabled' => 'boolean|required',
-            'application.http_basic_auth_username' => 'string|nullable',
-            'application.http_basic_auth_password' => 'string|nullable',
-            'application.watch_paths' => 'nullable',
-            'application.redirect' => 'string|required',
+            'name' => ValidationPatterns::nameRules(),
+            'description' => ValidationPatterns::descriptionRules(),
+            'fqdn' => 'nullable',
+            'git_repository' => 'required',
+            'git_branch' => 'required',
+            'git_commit_sha' => 'nullable',
+            'install_command' => 'nullable',
+            'build_command' => 'nullable',
+            'start_command' => 'nullable',
+            'build_pack' => 'required',
+            'static_image' => 'required',
+            'base_directory' => 'required',
+            'publish_directory' => 'nullable',
+            'ports_exposes' => 'required',
+            'ports_mappings' => 'nullable',
+            'custom_network_aliases' => 'nullable',
+            'dockerfile' => 'nullable',
+            'docker_registry_image_name' => 'nullable',
+            'docker_registry_image_tag' => 'nullable',
+            'dockerfile_location' => 'nullable',
+            'docker_compose_location' => 'nullable',
+            'docker_compose' => 'nullable',
+            'docker_compose_raw' => 'nullable',
+            'dockerfile_target_build' => 'nullable',
+            'docker_compose_custom_start_command' => 'nullable',
+            'docker_compose_custom_build_command' => 'nullable',
+            'custom_labels' => 'nullable',
+            'custom_docker_run_options' => 'nullable',
+            'pre_deployment_command' => 'nullable',
+            'pre_deployment_command_container' => 'nullable',
+            'post_deployment_command' => 'nullable',
+            'post_deployment_command_container' => 'nullable',
+            'custom_nginx_configuration' => 'nullable',
+            'is_static' => 'boolean|required',
+            'is_spa' => 'boolean|required',
+            'is_build_server_enabled' => 'boolean|required',
+            'is_container_label_escape_enabled' => 'boolean|required',
+            'is_container_label_readonly_enabled' => 'boolean|required',
+            'is_preserve_repository_enabled' => 'boolean|required',
+            'is_http_basic_auth_enabled' => 'boolean|required',
+            'http_basic_auth_username' => 'string|nullable',
+            'http_basic_auth_password' => 'string|nullable',
+            'watch_paths' => 'nullable',
+            'redirect' => 'string|required',
         ];
     }
 
@@ -118,31 +190,31 @@ class General extends Component
         return array_merge(
             ValidationPatterns::combinedMessages(),
             [
-                'application.name.required' => 'The Name field is required.',
-                'application.name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
-                'application.description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
-                'application.git_repository.required' => 'The Git Repository field is required.',
-                'application.git_branch.required' => 'The Git Branch field is required.',
-                'application.build_pack.required' => 'The Build Pack field is required.',
-                'application.static_image.required' => 'The Static Image field is required.',
-                'application.base_directory.required' => 'The Base Directory field is required.',
-                'application.ports_exposes.required' => 'The Exposed Ports field is required.',
-                'application.settings.is_static.required' => 'The Static setting is required.',
-                'application.settings.is_static.boolean' => 'The Static setting must be true or false.',
-                'application.settings.is_spa.required' => 'The SPA setting is required.',
-                'application.settings.is_spa.boolean' => 'The SPA setting must be true or false.',
-                'application.settings.is_build_server_enabled.required' => 'The Build Server setting is required.',
-                'application.settings.is_build_server_enabled.boolean' => 'The Build Server setting must be true or false.',
-                'application.settings.is_container_label_escape_enabled.required' => 'The Container Label Escape setting is required.',
-                'application.settings.is_container_label_escape_enabled.boolean' => 'The Container Label Escape setting must be true or false.',
-                'application.settings.is_container_label_readonly_enabled.required' => 'The Container Label Readonly setting is required.',
-                'application.settings.is_container_label_readonly_enabled.boolean' => 'The Container Label Readonly setting must be true or false.',
-                'application.settings.is_preserve_repository_enabled.required' => 'The Preserve Repository setting is required.',
-                'application.settings.is_preserve_repository_enabled.boolean' => 'The Preserve Repository setting must be true or false.',
-                'application.is_http_basic_auth_enabled.required' => 'The HTTP Basic Auth setting is required.',
-                'application.is_http_basic_auth_enabled.boolean' => 'The HTTP Basic Auth setting must be true or false.',
-                'application.redirect.required' => 'The Redirect setting is required.',
-                'application.redirect.string' => 'The Redirect setting must be a string.',
+                'name.required' => 'The Name field is required.',
+                'name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
+                'description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
+                'git_repository.required' => 'The Git Repository field is required.',
+                'git_branch.required' => 'The Git Branch field is required.',
+                'build_pack.required' => 'The Build Pack field is required.',
+                'static_image.required' => 'The Static Image field is required.',
+                'base_directory.required' => 'The Base Directory field is required.',
+                'ports_exposes.required' => 'The Exposed Ports field is required.',
+                'is_static.required' => 'The Static setting is required.',
+                'is_static.boolean' => 'The Static setting must be true or false.',
+                'is_spa.required' => 'The SPA setting is required.',
+                'is_spa.boolean' => 'The SPA setting must be true or false.',
+                'is_build_server_enabled.required' => 'The Build Server setting is required.',
+                'is_build_server_enabled.boolean' => 'The Build Server setting must be true or false.',
+                'is_container_label_escape_enabled.required' => 'The Container Label Escape setting is required.',
+                'is_container_label_escape_enabled.boolean' => 'The Container Label Escape setting must be true or false.',
+                'is_container_label_readonly_enabled.required' => 'The Container Label Readonly setting is required.',
+                'is_container_label_readonly_enabled.boolean' => 'The Container Label Readonly setting must be true or false.',
+                'is_preserve_repository_enabled.required' => 'The Preserve Repository setting is required.',
+                'is_preserve_repository_enabled.boolean' => 'The Preserve Repository setting must be true or false.',
+                'is_http_basic_auth_enabled.required' => 'The HTTP Basic Auth setting is required.',
+                'is_http_basic_auth_enabled.boolean' => 'The HTTP Basic Auth setting must be true or false.',
+                'redirect.required' => 'The Redirect setting is required.',
+                'redirect.string' => 'The Redirect setting must be a string.',
             ]
         );
     }
@@ -193,11 +265,15 @@ class General extends Component
             $this->parsedServices = $this->application->parse();
             if (is_null($this->parsedServices) || empty($this->parsedServices)) {
                 $this->dispatch('error', 'Failed to parse your docker-compose file. Please check the syntax and try again.');
+                // Still sync data even if parse fails, so form fields are populated
+                $this->syncFromModel();
 
                 return;
             }
         } catch (\Throwable $e) {
             $this->dispatch('error', $e->getMessage());
+            // Still sync data even on error, so form fields are populated
+            $this->syncFromModel();
         }
         if ($this->application->build_pack === 'dockercompose') {
             // Only update if user has permission
@@ -210,17 +286,14 @@ class General extends Component
             }
         }
         $this->parsedServiceDomains = $this->application->docker_compose_domains ? json_decode($this->application->docker_compose_domains, true) : [];
-        // Convert service names with dots to use underscores for HTML form binding
+        // Convert service names with dots and dashes to use underscores for HTML form binding
         $sanitizedDomains = [];
         foreach ($this->parsedServiceDomains as $serviceName => $domain) {
-            $sanitizedKey = str($serviceName)->slug('_')->toString();
+            $sanitizedKey = str($serviceName)->replace('-', '_')->replace('.', '_')->toString();
             $sanitizedDomains[$sanitizedKey] = $domain;
         }
         $this->parsedServiceDomains = $sanitizedDomains;
 
-        $this->ports_exposes = $this->application->ports_exposes;
-        $this->is_preserve_repository_enabled = $this->application->settings->is_preserve_repository_enabled;
-        $this->is_container_label_escape_enabled = $this->application->settings->is_container_label_escape_enabled;
         $this->customLabels = $this->application->parseContainerLabels();
         if (! $this->customLabels && $this->application->destination->server->proxyType() !== 'NONE' && $this->application->settings->is_container_label_readonly_enabled === true) {
             // Only update custom labels if user has permission
@@ -249,6 +322,60 @@ class General extends Component
         if (str($this->application->status)->startsWith('running') && is_null($this->application->config_hash)) {
             $this->dispatch('configurationChanged');
         }
+
+        // Sync data from model to properties at the END, after all business logic
+        // This ensures any modifications to $this->application during mount() are reflected in properties
+        $this->syncFromModel();
+    }
+
+    protected function getModelBindings(): array
+    {
+        return [
+            'name' => 'application.name',
+            'description' => 'application.description',
+            'fqdn' => 'application.fqdn',
+            'git_repository' => 'application.git_repository',
+            'git_branch' => 'application.git_branch',
+            'git_commit_sha' => 'application.git_commit_sha',
+            'install_command' => 'application.install_command',
+            'build_command' => 'application.build_command',
+            'start_command' => 'application.start_command',
+            'build_pack' => 'application.build_pack',
+            'static_image' => 'application.static_image',
+            'base_directory' => 'application.base_directory',
+            'publish_directory' => 'application.publish_directory',
+            'ports_exposes' => 'application.ports_exposes',
+            'ports_mappings' => 'application.ports_mappings',
+            'custom_network_aliases' => 'application.custom_network_aliases',
+            'dockerfile' => 'application.dockerfile',
+            'dockerfile_location' => 'application.dockerfile_location',
+            'dockerfile_target_build' => 'application.dockerfile_target_build',
+            'docker_registry_image_name' => 'application.docker_registry_image_name',
+            'docker_registry_image_tag' => 'application.docker_registry_image_tag',
+            'docker_compose_location' => 'application.docker_compose_location',
+            'docker_compose' => 'application.docker_compose',
+            'docker_compose_raw' => 'application.docker_compose_raw',
+            'docker_compose_custom_start_command' => 'application.docker_compose_custom_start_command',
+            'docker_compose_custom_build_command' => 'application.docker_compose_custom_build_command',
+            'custom_labels' => 'application.custom_labels',
+            'custom_docker_run_options' => 'application.custom_docker_run_options',
+            'pre_deployment_command' => 'application.pre_deployment_command',
+            'pre_deployment_command_container' => 'application.pre_deployment_command_container',
+            'post_deployment_command' => 'application.post_deployment_command',
+            'post_deployment_command_container' => 'application.post_deployment_command_container',
+            'custom_nginx_configuration' => 'application.custom_nginx_configuration',
+            'is_static' => 'application.settings.is_static',
+            'is_spa' => 'application.settings.is_spa',
+            'is_build_server_enabled' => 'application.settings.is_build_server_enabled',
+            'is_preserve_repository_enabled' => 'application.settings.is_preserve_repository_enabled',
+            'is_container_label_escape_enabled' => 'application.settings.is_container_label_escape_enabled',
+            'is_container_label_readonly_enabled' => 'application.settings.is_container_label_readonly_enabled',
+            'is_http_basic_auth_enabled' => 'application.is_http_basic_auth_enabled',
+            'http_basic_auth_username' => 'application.http_basic_auth_username',
+            'http_basic_auth_password' => 'application.http_basic_auth_password',
+            'watch_paths' => 'application.watch_paths',
+            'redirect' => 'application.redirect',
+        ];
     }
 
     public function instantSave()
@@ -256,6 +383,12 @@ class General extends Component
         try {
             $this->authorize('update', $this->application);
 
+            $oldPortsExposes = $this->application->ports_exposes;
+            $oldIsContainerLabelEscapeEnabled = $this->application->settings->is_container_label_escape_enabled;
+            $oldIsPreserveRepositoryEnabled = $this->application->settings->is_preserve_repository_enabled;
+
+            $this->syncToModel();
+
             if ($this->application->settings->isDirty('is_spa')) {
                 $this->generateNginxConfiguration($this->application->settings->is_spa ? 'spa' : 'static');
             }
@@ -265,20 +398,21 @@ class General extends Component
             $this->application->settings->save();
             $this->dispatch('success', 'Settings saved.');
             $this->application->refresh();
+            $this->syncFromModel();
 
             // If port_exposes changed, reset default labels
-            if ($this->ports_exposes !== $this->application->ports_exposes || $this->is_container_label_escape_enabled !== $this->application->settings->is_container_label_escape_enabled) {
+            if ($oldPortsExposes !== $this->ports_exposes || $oldIsContainerLabelEscapeEnabled !== $this->is_container_label_escape_enabled) {
                 $this->resetDefaultLabels(false);
             }
-            if ($this->is_preserve_repository_enabled !== $this->application->settings->is_preserve_repository_enabled) {
-                if ($this->application->settings->is_preserve_repository_enabled === false) {
+            if ($oldIsPreserveRepositoryEnabled !== $this->is_preserve_repository_enabled) {
+                if ($this->is_preserve_repository_enabled === false) {
                     $this->application->fileStorages->each(function ($storage) {
-                        $storage->is_based_on_git = $this->application->settings->is_preserve_repository_enabled;
+                        $storage->is_based_on_git = $this->is_preserve_repository_enabled;
                         $storage->save();
                     });
                 }
             }
-            if ($this->application->settings->is_container_label_readonly_enabled) {
+            if ($this->is_container_label_readonly_enabled) {
                 $this->resetDefaultLabels(false);
             }
         } catch (\Throwable $e) {
@@ -304,11 +438,16 @@ class General extends Component
 
             // Refresh parsedServiceDomains to reflect any changes in docker_compose_domains
             $this->application->refresh();
+
+            // Sync the docker_compose_raw from the model to the component property
+            // This ensures the Monaco editor displays the loaded compose file
+            $this->syncFromModel();
+
             $this->parsedServiceDomains = $this->application->docker_compose_domains ? json_decode($this->application->docker_compose_domains, true) : [];
-            // Convert service names with dots to use underscores for HTML form binding
+            // Convert service names with dots and dashes to use underscores for HTML form binding
             $sanitizedDomains = [];
             foreach ($this->parsedServiceDomains as $serviceName => $domain) {
-                $sanitizedKey = str($serviceName)->slug('_')->toString();
+                $sanitizedKey = str($serviceName)->replace('-', '_')->replace('.', '_')->toString();
                 $sanitizedDomains[$sanitizedKey] = $domain;
             }
             $this->parsedServiceDomains = $sanitizedDomains;
@@ -334,7 +473,7 @@ class General extends Component
 
             $uuid = new Cuid2;
             $domain = generateUrl(server: $this->application->destination->server, random: $uuid);
-            $sanitizedKey = str($serviceName)->slug('_')->toString();
+            $sanitizedKey = str($serviceName)->replace('-', '_')->replace('.', '_')->toString();
             $this->parsedServiceDomains[$sanitizedKey]['domain'] = $domain;
 
             // Convert back to original service names for storage
@@ -344,7 +483,7 @@ class General extends Component
                 $originalServiceName = $key;
                 if (isset($this->parsedServices['services'])) {
                     foreach ($this->parsedServices['services'] as $originalName => $service) {
-                        if (str($originalName)->slug('_')->toString() === $key) {
+                        if (str($originalName)->replace('-', '_')->replace('.', '_')->toString() === $key) {
                             $originalServiceName = $originalName;
                             break;
                         }
@@ -366,21 +505,21 @@ class General extends Component
         }
     }
 
-    public function updatedApplicationBaseDirectory()
+    public function updatedBaseDirectory()
     {
-        if ($this->application->build_pack === 'dockercompose') {
+        if ($this->build_pack === 'dockercompose') {
             $this->loadComposeFile();
         }
     }
 
-    public function updatedApplicationSettingsIsStatic($value)
+    public function updatedIsStatic($value)
     {
         if ($value) {
             $this->generateNginxConfiguration();
         }
     }
 
-    public function updatedApplicationBuildPack()
+    public function updatedBuildPack()
     {
         // Check if user has permission to update
         try {
@@ -388,21 +527,28 @@ class General extends Component
         } catch (\Illuminate\Auth\Access\AuthorizationException $e) {
             // User doesn't have permission, revert the change and return
             $this->application->refresh();
+            $this->syncFromModel();
 
             return;
         }
 
-        if ($this->application->build_pack !== 'nixpacks') {
+        // Sync property to model before checking/modifying
+        $this->syncToModel();
+
+        if ($this->build_pack !== 'nixpacks') {
+            $this->is_static = false;
             $this->application->settings->is_static = false;
             $this->application->settings->save();
         } else {
-            $this->application->ports_exposes = $this->ports_exposes = 3000;
+            $this->ports_exposes = 3000;
+            $this->application->ports_exposes = 3000;
             $this->resetDefaultLabels(false);
         }
-        if ($this->application->build_pack === 'dockercompose') {
+        if ($this->build_pack === 'dockercompose') {
             // Only update if user has permission
             try {
                 $this->authorize('update', $this->application);
+                $this->fqdn = null;
                 $this->application->fqdn = null;
                 $this->application->settings->save();
             } catch (\Illuminate\Auth\Access\AuthorizationException $e) {
@@ -421,8 +567,9 @@ class General extends Component
                 $this->application->environment_variables_preview()->where('key', 'LIKE', 'SERVICE_URL_%')->delete();
             }
         }
-        if ($this->application->build_pack === 'static') {
-            $this->application->ports_exposes = $this->ports_exposes = 80;
+        if ($this->build_pack === 'static') {
+            $this->ports_exposes = 80;
+            $this->application->ports_exposes = 80;
             $this->resetDefaultLabels(false);
             $this->generateNginxConfiguration();
         }
@@ -438,8 +585,11 @@ class General extends Component
             $server = data_get($this->application, 'destination.server');
             if ($server) {
                 $fqdn = generateUrl(server: $server, random: $this->application->uuid);
-                $this->application->fqdn = $fqdn;
+                $this->fqdn = $fqdn;
+                $this->syncToModel();
                 $this->application->save();
+                $this->application->refresh();
+                $this->syncFromModel();
                 $this->resetDefaultLabels();
                 $this->dispatch('success', 'Wildcard domain generated.');
             }
@@ -453,8 +603,11 @@ class General extends Component
         try {
             $this->authorize('update', $this->application);
 
-            $this->application->custom_nginx_configuration = defaultNginxConfiguration($type);
+            $this->custom_nginx_configuration = defaultNginxConfiguration($type);
+            $this->syncToModel();
             $this->application->save();
+            $this->application->refresh();
+            $this->syncFromModel();
             $this->dispatch('success', 'Nginx configuration generated.');
         } catch (\Throwable $e) {
             return handleError($e, $this);
@@ -464,15 +617,16 @@ class General extends Component
     public function resetDefaultLabels($manualReset = false)
     {
         try {
-            if (! $this->application->settings->is_container_label_readonly_enabled && ! $manualReset) {
+            if (! $this->is_container_label_readonly_enabled && ! $manualReset) {
                 return;
             }
             $this->customLabels = str(implode('|coolify|', generateLabelsApplication($this->application)))->replace('|coolify|', "\n");
-            $this->ports_exposes = $this->application->ports_exposes;
-            $this->is_container_label_escape_enabled = $this->application->settings->is_container_label_escape_enabled;
-            $this->application->custom_labels = base64_encode($this->customLabels);
+            $this->custom_labels = base64_encode($this->customLabels);
+            $this->syncToModel();
             $this->application->save();
-            if ($this->application->build_pack === 'dockercompose') {
+            $this->application->refresh();
+            $this->syncFromModel();
+            if ($this->build_pack === 'dockercompose') {
                 $this->loadComposeFile(showToast: false);
             }
             $this->dispatch('configurationChanged');
@@ -483,8 +637,8 @@ class General extends Component
 
     public function checkFqdns($showToaster = true)
     {
-        if (data_get($this->application, 'fqdn')) {
-            $domains = str($this->application->fqdn)->trim()->explode(',');
+        if ($this->fqdn) {
+            $domains = str($this->fqdn)->trim()->explode(',');
             if ($this->application->additional_servers->count() === 0) {
                 foreach ($domains as $domain) {
                     if (! validateDNSEntry($domain, $this->application->destination->server)) {
@@ -507,7 +661,8 @@ class General extends Component
                 $this->forceSaveDomains = false;
             }
 
-            $this->application->fqdn = $domains->implode(',');
+            $this->fqdn = $domains->implode(',');
+            $this->application->fqdn = $this->fqdn;
             $this->resetDefaultLabels(false);
         }
 
@@ -544,21 +699,30 @@ class General extends Component
     {
         try {
             $this->authorize('update', $this->application);
-            $this->application->fqdn = str($this->application->fqdn)->replaceEnd(',', '')->trim();
-            $this->application->fqdn = str($this->application->fqdn)->replaceStart(',', '')->trim();
-            $this->application->fqdn = str($this->application->fqdn)->trim()->explode(',')->map(function ($domain) {
+
+            $this->validate();
+
+            $oldPortsExposes = $this->application->ports_exposes;
+            $oldIsContainerLabelEscapeEnabled = $this->application->settings->is_container_label_escape_enabled;
+            $oldDockerComposeLocation = $this->initialDockerComposeLocation;
+
+            // Process FQDN with intermediate variable to avoid Collection/string confusion
+            $this->fqdn = str($this->fqdn)->replaceEnd(',', '')->trim()->toString();
+            $this->fqdn = str($this->fqdn)->replaceStart(',', '')->trim()->toString();
+            $domains = str($this->fqdn)->trim()->explode(',')->map(function ($domain) {
                 $domain = trim($domain);
                 Url::fromString($domain, ['http', 'https']);
 
                 return str($domain)->lower();
             });
 
-            $this->application->fqdn = $this->application->fqdn->unique()->implode(',');
-            $warning = sslipDomainWarning($this->application->fqdn);
+            $this->fqdn = $domains->unique()->implode(',');
+            $warning = sslipDomainWarning($this->fqdn);
             if ($warning) {
                 $this->dispatch('warning', __('warning.sslipdomain'));
             }
-            // $this->resetDefaultLabels();
+
+            $this->syncToModel();
 
             if ($this->application->isDirty('redirect')) {
                 $this->setRedirect();
@@ -578,39 +742,42 @@ class General extends Component
                 $this->application->save();
             }
 
-            if ($this->application->build_pack === 'dockercompose' && $this->initialDockerComposeLocation !== $this->application->docker_compose_location) {
+            if ($this->build_pack === 'dockercompose' && $oldDockerComposeLocation !== $this->docker_compose_location) {
                 $compose_return = $this->loadComposeFile(showToast: false);
                 if ($compose_return instanceof \Livewire\Features\SupportEvents\Event) {
                     return;
                 }
             }
-            $this->validate();
 
-            if ($this->ports_exposes !== $this->application->ports_exposes || $this->is_container_label_escape_enabled !== $this->application->settings->is_container_label_escape_enabled) {
+            if ($oldPortsExposes !== $this->ports_exposes || $oldIsContainerLabelEscapeEnabled !== $this->is_container_label_escape_enabled) {
                 $this->resetDefaultLabels();
             }
-            if (data_get($this->application, 'build_pack') === 'dockerimage') {
+            if ($this->build_pack === 'dockerimage') {
                 $this->validate([
-                    'application.docker_registry_image_name' => 'required',
+                    'docker_registry_image_name' => 'required',
                 ]);
             }
 
-            if (data_get($this->application, 'custom_docker_run_options')) {
-                $this->application->custom_docker_run_options = str($this->application->custom_docker_run_options)->trim();
+            if ($this->custom_docker_run_options) {
+                $this->custom_docker_run_options = str($this->custom_docker_run_options)->trim()->toString();
+                $this->application->custom_docker_run_options = $this->custom_docker_run_options;
             }
-            if (data_get($this->application, 'dockerfile')) {
-                $port = get_port_from_dockerfile($this->application->dockerfile);
-                if ($port && ! $this->application->ports_exposes) {
+            if ($this->dockerfile) {
+                $port = get_port_from_dockerfile($this->dockerfile);
+                if ($port && ! $this->ports_exposes) {
+                    $this->ports_exposes = $port;
                     $this->application->ports_exposes = $port;
                 }
             }
-            if ($this->application->base_directory && $this->application->base_directory !== '/') {
-                $this->application->base_directory = rtrim($this->application->base_directory, '/');
+            if ($this->base_directory && $this->base_directory !== '/') {
+                $this->base_directory = rtrim($this->base_directory, '/');
+                $this->application->base_directory = $this->base_directory;
             }
-            if ($this->application->publish_directory && $this->application->publish_directory !== '/') {
-                $this->application->publish_directory = rtrim($this->application->publish_directory, '/');
+            if ($this->publish_directory && $this->publish_directory !== '/') {
+                $this->publish_directory = rtrim($this->publish_directory, '/');
+                $this->application->publish_directory = $this->publish_directory;
             }
-            if ($this->application->build_pack === 'dockercompose') {
+            if ($this->build_pack === 'dockercompose') {
                 $this->application->docker_compose_domains = json_encode($this->parsedServiceDomains);
                 if ($this->application->isDirty('docker_compose_domains')) {
                     foreach ($this->parsedServiceDomains as $service) {
@@ -641,12 +808,12 @@ class General extends Component
             }
             $this->application->custom_labels = base64_encode($this->customLabels);
             $this->application->save();
+            $this->application->refresh();
+            $this->syncFromModel();
             $showToaster && ! $warning && $this->dispatch('success', 'Application settings updated!');
         } catch (\Throwable $e) {
-            $originalFqdn = $this->application->getOriginal('fqdn');
-            if ($originalFqdn !== $this->application->fqdn) {
-                $this->application->fqdn = $originalFqdn;
-            }
+            $this->application->refresh();
+            $this->syncFromModel();
 
             return handleError($e, $this);
         } finally {

app/Livewire/Project/Application/Heading.php

@@ -58,6 +58,11 @@ class Heading extends Component
         }
     }
 
+    public function manualCheckStatus()
+    {
+        $this->checkStatus();
+    }
+
     public function force_deploy_without_cache()
     {
         $this->authorize('deploy', $this->application);

app/Livewire/Project/Application/Previews.php

@@ -33,14 +33,34 @@ class Previews extends Component
 
     public $pendingPreviewId = null;
 
+    public array $previewFqdns = [];
+
     protected $rules = [
-        'application.previews.*.fqdn' => 'string|nullable',
+        'previewFqdns.*' => 'string|nullable',
     ];
 
     public function mount()
     {
         $this->pull_requests = collect();
         $this->parameters = get_route_parameters();
+        $this->syncData(false);
+    }
+
+    private function syncData(bool $toModel = false): void
+    {
+        if ($toModel) {
+            foreach ($this->previewFqdns as $key => $fqdn) {
+                $preview = $this->application->previews->get($key);
+                if ($preview) {
+                    $preview->fqdn = $fqdn;
+                }
+            }
+        } else {
+            $this->previewFqdns = [];
+            foreach ($this->application->previews as $key => $preview) {
+                $this->previewFqdns[$key] = $preview->fqdn;
+            }
+        }
     }
 
     public function load_prs()
@@ -73,35 +93,52 @@ class Previews extends Component
             $this->authorize('update', $this->application);
             $success = true;
             $preview = $this->application->previews->find($preview_id);
-            if (data_get_str($preview, 'fqdn')->isNotEmpty()) {
-                $preview->fqdn = str($preview->fqdn)->replaceEnd(',', '')->trim();
-                $preview->fqdn = str($preview->fqdn)->replaceStart(',', '')->trim();
-                $preview->fqdn = str($preview->fqdn)->trim()->lower();
-                if (! validateDNSEntry($preview->fqdn, $this->application->destination->server)) {
-                    $this->dispatch('error', 'Validating DNS failed.', "Make sure you have added the DNS records correctly.<br><br>$preview->fqdn->{$this->application->destination->server->ip}<br><br>Check this <a target='_blank' class='underline dark:text-white' href='https://coolify.io/docs/knowledge-base/dns-configuration'>documentation</a> for further help.");
-                    $success = false;
-                }
-                // Check for domain conflicts if not forcing save
-                if (! $this->forceSaveDomains) {
-                    $result = checkDomainUsage(resource: $this->application, domain: $preview->fqdn);
-                    if ($result['hasConflicts']) {
-                        $this->domainConflicts = $result['conflicts'];
-                        $this->showDomainConflictModal = true;
-                        $this->pendingPreviewId = $preview_id;
-
-                        return;
-                    }
-                } else {
-                    // Reset the force flag after using it
-                    $this->forceSaveDomains = false;
-                }
-            }
 
             if (! $preview) {
                 throw new \Exception('Preview not found');
             }
-            $success && $preview->save();
-            $success && $this->dispatch('success', 'Preview saved.<br><br>Do not forget to redeploy the preview to apply the changes.');
+
+            // Find the key for this preview in the collection
+            $previewKey = $this->application->previews->search(function ($item) use ($preview_id) {
+                return $item->id == $preview_id;
+            });
+
+            if ($previewKey !== false && isset($this->previewFqdns[$previewKey])) {
+                $fqdn = $this->previewFqdns[$previewKey];
+
+                if (! empty($fqdn)) {
+                    $fqdn = str($fqdn)->replaceEnd(',', '')->trim();
+                    $fqdn = str($fqdn)->replaceStart(',', '')->trim();
+                    $fqdn = str($fqdn)->trim()->lower();
+                    $this->previewFqdns[$previewKey] = $fqdn;
+
+                    if (! validateDNSEntry($fqdn, $this->application->destination->server)) {
+                        $this->dispatch('error', 'Validating DNS failed.', "Make sure you have added the DNS records correctly.<br><br>$fqdn->{$this->application->destination->server->ip}<br><br>Check this <a target='_blank' class='underline dark:text-white' href='https://coolify.io/docs/knowledge-base/dns-configuration'>documentation</a> for further help.");
+                        $success = false;
+                    }
+
+                    // Check for domain conflicts if not forcing save
+                    if (! $this->forceSaveDomains) {
+                        $result = checkDomainUsage(resource: $this->application, domain: $fqdn);
+                        if ($result['hasConflicts']) {
+                            $this->domainConflicts = $result['conflicts'];
+                            $this->showDomainConflictModal = true;
+                            $this->pendingPreviewId = $preview_id;
+
+                            return;
+                        }
+                    } else {
+                        // Reset the force flag after using it
+                        $this->forceSaveDomains = false;
+                    }
+                }
+            }
+
+            if ($success) {
+                $this->syncData(true);
+                $preview->save();
+                $this->dispatch('success', 'Preview saved.<br><br>Do not forget to redeploy the preview to apply the changes.');
+            }
         } catch (\Throwable $e) {
             return handleError($e, $this);
         }
@@ -121,6 +158,7 @@ class Previews extends Component
             if ($this->application->build_pack === 'dockercompose') {
                 $preview->generate_preview_fqdn_compose();
                 $this->application->refresh();
+                $this->syncData(false);
                 $this->dispatch('success', 'Domain generated.');
 
                 return;
@@ -128,6 +166,7 @@ class Previews extends Component
 
             $preview->generate_preview_fqdn();
             $this->application->refresh();
+            $this->syncData(false);
             $this->dispatch('update_links');
             $this->dispatch('success', 'Domain generated.');
         } catch (\Throwable $e) {
@@ -152,6 +191,7 @@ class Previews extends Component
                 }
                 $found->generate_preview_fqdn_compose();
                 $this->application->refresh();
+                $this->syncData(false);
             } else {
                 $this->setDeploymentUuid();
                 $found = ApplicationPreview::where('application_id', $this->application->id)->where('pull_request_id', $pull_request_id)->first();
@@ -164,6 +204,7 @@ class Previews extends Component
                 }
                 $found->generate_preview_fqdn();
                 $this->application->refresh();
+                $this->syncData(false);
                 $this->dispatch('update_links');
                 $this->dispatch('success', 'Preview added.');
             }

app/Livewire/Project/Application/PreviewsCompose.php

@@ -18,6 +18,13 @@ class PreviewsCompose extends Component
 
     public ApplicationPreview $preview;
 
+    public ?string $domain = null;
+
+    public function mount()
+    {
+        $this->domain = data_get($this->service, 'domain');
+    }
+
     public function render()
     {
         return view('livewire.project.application.previews-compose');
@@ -28,10 +35,10 @@ class PreviewsCompose extends Component
         try {
             $this->authorize('update', $this->preview->application);
 
-            $domain = data_get($this->service, 'domain');
             $docker_compose_domains = data_get($this->preview, 'docker_compose_domains');
-            $docker_compose_domains = json_decode($docker_compose_domains, true);
-            $docker_compose_domains[$this->serviceName]['domain'] = $domain;
+            $docker_compose_domains = json_decode($docker_compose_domains, true) ?: [];
+            $docker_compose_domains[$this->serviceName] = $docker_compose_domains[$this->serviceName] ?? [];
+            $docker_compose_domains[$this->serviceName]['domain'] = $this->domain;
             $this->preview->docker_compose_domains = json_encode($docker_compose_domains);
             $this->preview->save();
             $this->dispatch('update_links');
@@ -46,7 +53,7 @@ class PreviewsCompose extends Component
         try {
             $this->authorize('update', $this->preview->application);
 
-            $domains = collect(json_decode($this->preview->application->docker_compose_domains)) ?? collect();
+            $domains = collect(json_decode($this->preview->application->docker_compose_domains, true) ?: []);
             $domain = $domains->first(function ($_, $key) {
                 return $key === $this->serviceName;
             });
@@ -68,21 +75,40 @@ class PreviewsCompose extends Component
                 $preview_fqdn = str($generated_fqdn)->before('://').'://'.$preview_fqdn;
             } else {
                 // Use the existing domain from the main application
-                $url = Url::fromString($domain_string);
+                // Handle multiple domains separated by commas
+                $domain_list = explode(',', $domain_string);
+                $preview_fqdns = [];
                 $template = $this->preview->application->preview_url_template;
-                $host = $url->getHost();
-                $schema = $url->getScheme();
                 $random = new Cuid2;
-                $preview_fqdn = str_replace('{{random}}', $random, $template);
-                $preview_fqdn = str_replace('{{domain}}', $host, $preview_fqdn);
-                $preview_fqdn = str_replace('{{pr_id}}', $this->preview->pull_request_id, $preview_fqdn);
-                $preview_fqdn = "$schema://$preview_fqdn";
+
+                foreach ($domain_list as $single_domain) {
+                    $single_domain = trim($single_domain);
+                    if (empty($single_domain)) {
+                        continue;
+                    }
+
+                    $url = Url::fromString($single_domain);
+                    $host = $url->getHost();
+                    $schema = $url->getScheme();
+                    $portInt = $url->getPort();
+                    $port = $portInt !== null ? ':'.$portInt : '';
+
+                    $preview_fqdn = str_replace('{{random}}', $random, $template);
+                    $preview_fqdn = str_replace('{{domain}}', $host, $preview_fqdn);
+                    $preview_fqdn = str_replace('{{pr_id}}', $this->preview->pull_request_id, $preview_fqdn);
+                    $preview_fqdn = str_replace('{{port}}', $port, $preview_fqdn);
+                    $preview_fqdns[] = "$schema://$preview_fqdn";
+                }
+
+                $preview_fqdn = implode(',', $preview_fqdns);
             }
 
             // Save the generated domain
+            $this->domain = $preview_fqdn;
             $docker_compose_domains = data_get($this->preview, 'docker_compose_domains');
-            $docker_compose_domains = json_decode($docker_compose_domains, true);
-            $docker_compose_domains[$this->serviceName]['domain'] = $this->service->domain = $preview_fqdn;
+            $docker_compose_domains = json_decode($docker_compose_domains, true) ?: [];
+            $docker_compose_domains[$this->serviceName] = $docker_compose_domains[$this->serviceName] ?? [];
+            $docker_compose_domains[$this->serviceName]['domain'] = $this->domain;
             $this->preview->docker_compose_domains = json_encode($docker_compose_domains);
             $this->preview->save();
 

app/Livewire/Project/Application/Source.php

@@ -47,6 +47,21 @@ class Source extends Component
         }
     }
 
+    public function updatedGitRepository()
+    {
+        $this->gitRepository = trim($this->gitRepository);
+    }
+
+    public function updatedGitBranch()
+    {
+        $this->gitBranch = trim($this->gitBranch);
+    }
+
+    public function updatedGitCommitSha()
+    {
+        $this->gitCommitSha = trim($this->gitCommitSha);
+    }
+
     public function syncData(bool $toModel = false)
     {
         if ($toModel) {
@@ -57,6 +72,9 @@ class Source extends Component
                 'git_commit_sha' => $this->gitCommitSha,
                 'private_key_id' => $this->privateKeyId,
             ]);
+            // Refresh to get the trimmed values from the model
+            $this->application->refresh();
+            $this->syncData(false);
         } else {
             $this->gitRepository = $this->application->git_repository;
             $this->gitBranch = $this->application->git_branch;

app/Livewire/Project/Database/BackupEdit.php

@@ -85,6 +85,7 @@ class BackupEdit extends Component
     public function mount()
     {
         try {
+            $this->authorize('view', $this->backup->database);
             $this->parameters = get_route_parameters();
             $this->syncData();
         } catch (Exception $e) {
@@ -208,7 +209,7 @@ class BackupEdit extends Component
 
         // Validate that disable_local_backup can only be true when S3 backup is enabled
         if ($this->backup->disable_local_backup && ! $this->backup->save_s3) {
-            throw new \Exception('Local backup can only be disabled when S3 backup is enabled.');
+            $this->backup->disable_local_backup = $this->disableLocalBackup = false;
         }
 
         $isValid = validate_cron_expression($this->backup->frequency);

app/Livewire/Project/Database/BackupExecutions.php

@@ -202,11 +202,6 @@ class BackupExecutions extends Component
 
     public function render()
     {
-        return view('livewire.project.database.backup-executions', [
-            'checkboxes' => [
-                ['id' => 'delete_backup_s3', 'label' => 'Delete the selected backup permanently from S3 Storage'],
-                // ['id' => 'delete_backup_sftp', 'label' => 'Delete the selected backup permanently from SFTP Storage'],
-            ],
-        ]);
+        return view('livewire.project.database.backup-executions');
     }
 }

app/Livewire/Project/Database/Clickhouse/General.php

@@ -16,7 +16,7 @@ class General extends Component
 {
     use AuthorizesRequests;
 
-    public Server $server;
+    public ?Server $server = null;
 
     public StandaloneClickhouse $database;
 
@@ -56,8 +56,14 @@ class General extends Component
     public function mount()
     {
         try {
+            $this->authorize('view', $this->database);
             $this->syncData();
             $this->server = data_get($this->database, 'destination.server');
+            if (! $this->server) {
+                $this->dispatch('error', 'Database destination server is not configured.');
+
+                return;
+            }
         } catch (\Throwable $e) {
             return handleError($e, $this);
         }

app/Livewire/Project/Database/Configuration.php

@@ -3,10 +3,13 @@
 namespace App\Livewire\Project\Database;
 
 use Auth;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
 use Livewire\Component;
 
 class Configuration extends Component
 {
+    use AuthorizesRequests;
+
     public $currentRoute;
 
     public $database;
@@ -42,6 +45,8 @@ class Configuration extends Component
                 ->where('uuid', request()->route('database_uuid'))
                 ->firstOrFail();
 
+            $this->authorize('view', $database);
+
             $this->database = $database;
             $this->project = $project;
             $this->environment = $environment;

app/Livewire/Project/Database/Dragonfly/General.php

@@ -6,7 +6,6 @@ use App\Actions\Database\StartDatabaseProxy;
 use App\Actions\Database\StopDatabaseProxy;
 use App\Helpers\SslHelper;
 use App\Models\Server;
-use App\Models\SslCertificate;
 use App\Models\StandaloneDragonfly;
 use App\Support\ValidationPatterns;
 use Carbon\Carbon;
@@ -19,7 +18,7 @@ class General extends Component
 {
     use AuthorizesRequests;
 
-    public Server $server;
+    public ?Server $server = null;
 
     public StandaloneDragonfly $database;
 
@@ -63,8 +62,14 @@ class General extends Component
     public function mount()
     {
         try {
+            $this->authorize('view', $this->database);
             $this->syncData();
             $this->server = data_get($this->database, 'destination.server');
+            if (! $this->server) {
+                $this->dispatch('error', 'Database destination server is not configured.');
+
+                return;
+            }
 
             $existingCert = $this->database->sslCertificates()->first();
 
@@ -249,13 +254,13 @@ class General extends Component
 
             $server = $this->database->destination->server;
 
-            $caCert = SslCertificate::where('server_id', $server->id)
+            $caCert = $server->sslCertificates()
                 ->where('is_ca_certificate', true)
                 ->first();
 
             if (! $caCert) {
                 $server->generateCaCertificate();
-                $caCert = SslCertificate::where('server_id', $server->id)->where('is_ca_certificate', true)->first();
+                $caCert = $server->sslCertificates()->where('is_ca_certificate', true)->first();
             }
 
             if (! $caCert) {

app/Livewire/Project/Database/Heading.php

@@ -62,6 +62,11 @@ class Heading extends Component
         }
     }
 
+    public function manualCheckStatus()
+    {
+        $this->checkStatus();
+    }
+
     public function mount()
     {
         $this->parameters = get_route_parameters();

app/Livewire/Project/Database/Import.php

@@ -131,6 +131,7 @@ EOD;
         if (is_null($resource)) {
             abort(404);
         }
+        $this->authorize('view', $resource);
         $this->resource = $resource;
         $this->server = $this->resource->destination->server;
         $this->container = $this->resource->uuid;

app/Livewire/Project/Database/Keydb/General.php

@@ -6,7 +6,6 @@ use App\Actions\Database\StartDatabaseProxy;
 use App\Actions\Database\StopDatabaseProxy;
 use App\Helpers\SslHelper;
 use App\Models\Server;
-use App\Models\SslCertificate;
 use App\Models\StandaloneKeydb;
 use App\Support\ValidationPatterns;
 use Carbon\Carbon;
@@ -19,7 +18,7 @@ class General extends Component
 {
     use AuthorizesRequests;
 
-    public Server $server;
+    public ?Server $server = null;
 
     public StandaloneKeydb $database;
 
@@ -59,15 +58,20 @@ class General extends Component
         return [
             "echo-private:team.{$teamId},DatabaseProxyStopped" => 'databaseProxyStopped',
             "echo-private:user.{$userId},DatabaseStatusChanged" => '$refresh',
-            'refresh' => '$refresh',
         ];
     }
 
     public function mount()
     {
         try {
+            $this->authorize('view', $this->database);
             $this->syncData();
             $this->server = data_get($this->database, 'destination.server');
+            if (! $this->server) {
+                $this->dispatch('error', 'Database destination server is not configured.');
+
+                return;
+            }
 
             $existingCert = $this->database->sslCertificates()->first();
 
@@ -255,7 +259,7 @@ class General extends Component
                 return;
             }
 
-            $caCert = SslCertificate::where('server_id', $existingCert->server_id)
+            $caCert = $this->server->sslCertificates()
                 ->where('is_ca_certificate', true)
                 ->first();
 

app/Livewire/Project/Database/Mariadb/General.php

@@ -6,7 +6,6 @@ use App\Actions\Database\StartDatabaseProxy;
 use App\Actions\Database\StopDatabaseProxy;
 use App\Helpers\SslHelper;
 use App\Models\Server;
-use App\Models\SslCertificate;
 use App\Models\StandaloneMariadb;
 use App\Support\ValidationPatterns;
 use Carbon\Carbon;
@@ -19,12 +18,38 @@ class General extends Component
 {
     use AuthorizesRequests;
 
-    protected $listeners = ['refresh'];
-
-    public Server $server;
+    public ?Server $server = null;
 
     public StandaloneMariadb $database;
 
+    public string $name;
+
+    public ?string $description = null;
+
+    public string $mariadbRootPassword;
+
+    public string $mariadbUser;
+
+    public string $mariadbPassword;
+
+    public string $mariadbDatabase;
+
+    public ?string $mariadbConf = null;
+
+    public string $image;
+
+    public ?string $portsMappings = null;
+
+    public ?bool $isPublic = null;
+
+    public ?int $publicPort = null;
+
+    public bool $isLogDrainEnabled = false;
+
+    public ?string $customDockerRunOptions = null;
+
+    public bool $enableSsl = false;
+
     public ?string $db_url = null;
 
     public ?string $db_url_public = null;
@@ -37,27 +62,26 @@ class General extends Component
 
         return [
             "echo-private:user.{$userId},DatabaseStatusChanged" => '$refresh',
-            'refresh' => '$refresh',
         ];
     }
 
     protected function rules(): array
     {
         return [
-            'database.name' => ValidationPatterns::nameRules(),
-            'database.description' => ValidationPatterns::descriptionRules(),
-            'database.mariadb_root_password' => 'required',
-            'database.mariadb_user' => 'required',
-            'database.mariadb_password' => 'required',
-            'database.mariadb_database' => 'required',
-            'database.mariadb_conf' => 'nullable',
-            'database.image' => 'required',
-            'database.ports_mappings' => 'nullable',
-            'database.is_public' => 'nullable|boolean',
-            'database.public_port' => 'nullable|integer',
-            'database.is_log_drain_enabled' => 'nullable|boolean',
-            'database.custom_docker_run_options' => 'nullable',
-            'database.enable_ssl' => 'boolean',
+            'name' => ValidationPatterns::nameRules(),
+            'description' => ValidationPatterns::descriptionRules(),
+            'mariadbRootPassword' => 'required',
+            'mariadbUser' => 'required',
+            'mariadbPassword' => 'required',
+            'mariadbDatabase' => 'required',
+            'mariadbConf' => 'nullable',
+            'image' => 'required',
+            'portsMappings' => 'nullable',
+            'isPublic' => 'nullable|boolean',
+            'publicPort' => 'nullable|integer',
+            'isLogDrainEnabled' => 'nullable|boolean',
+            'customDockerRunOptions' => 'nullable',
+            'enableSsl' => 'boolean',
         ];
     }
 
@@ -66,45 +90,96 @@ class General extends Component
         return array_merge(
             ValidationPatterns::combinedMessages(),
             [
-                'database.name.required' => 'The Name field is required.',
-                'database.name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
-                'database.description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
-                'database.mariadb_root_password.required' => 'The Root Password field is required.',
-                'database.mariadb_user.required' => 'The MariaDB User field is required.',
-                'database.mariadb_password.required' => 'The MariaDB Password field is required.',
-                'database.mariadb_database.required' => 'The MariaDB Database field is required.',
-                'database.image.required' => 'The Docker Image field is required.',
-                'database.public_port.integer' => 'The Public Port must be an integer.',
+                'name.required' => 'The Name field is required.',
+                'name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
+                'description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
+                'mariadbRootPassword.required' => 'The Root Password field is required.',
+                'mariadbUser.required' => 'The MariaDB User field is required.',
+                'mariadbPassword.required' => 'The MariaDB Password field is required.',
+                'mariadbDatabase.required' => 'The MariaDB Database field is required.',
+                'image.required' => 'The Docker Image field is required.',
+                'publicPort.integer' => 'The Public Port must be an integer.',
             ]
         );
     }
 
     protected $validationAttributes = [
-        'database.name' => 'Name',
-        'database.description' => 'Description',
-        'database.mariadb_root_password' => 'Root Password',
-        'database.mariadb_user' => 'User',
-        'database.mariadb_password' => 'Password',
-        'database.mariadb_database' => 'Database',
-        'database.mariadb_conf' => 'MariaDB Configuration',
-        'database.image' => 'Image',
-        'database.ports_mappings' => 'Port Mapping',
-        'database.is_public' => 'Is Public',
-        'database.public_port' => 'Public Port',
-        'database.custom_docker_run_options' => 'Custom Docker Options',
-        'database.enable_ssl' => 'Enable SSL',
+        'name' => 'Name',
+        'description' => 'Description',
+        'mariadbRootPassword' => 'Root Password',
+        'mariadbUser' => 'User',
+        'mariadbPassword' => 'Password',
+        'mariadbDatabase' => 'Database',
+        'mariadbConf' => 'MariaDB Configuration',
+        'image' => 'Image',
+        'portsMappings' => 'Port Mapping',
+        'isPublic' => 'Is Public',
+        'publicPort' => 'Public Port',
+        'customDockerRunOptions' => 'Custom Docker Options',
+        'enableSsl' => 'Enable SSL',
     ];
 
     public function mount()
     {
-        $this->db_url = $this->database->internal_db_url;
-        $this->db_url_public = $this->database->external_db_url;
-        $this->server = data_get($this->database, 'destination.server');
+        try {
+            $this->authorize('view', $this->database);
+            $this->syncData();
+            $this->server = data_get($this->database, 'destination.server');
+            if (! $this->server) {
+                $this->dispatch('error', 'Database destination server is not configured.');
 
-        $existingCert = $this->database->sslCertificates()->first();
+                return;
+            }
 
-        if ($existingCert) {
-            $this->certificateValidUntil = $existingCert->valid_until;
+            $existingCert = $this->database->sslCertificates()->first();
+
+            if ($existingCert) {
+                $this->certificateValidUntil = $existingCert->valid_until;
+            }
+        } catch (Exception $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function syncData(bool $toModel = false)
+    {
+        if ($toModel) {
+            $this->validate();
+            $this->database->name = $this->name;
+            $this->database->description = $this->description;
+            $this->database->mariadb_root_password = $this->mariadbRootPassword;
+            $this->database->mariadb_user = $this->mariadbUser;
+            $this->database->mariadb_password = $this->mariadbPassword;
+            $this->database->mariadb_database = $this->mariadbDatabase;
+            $this->database->mariadb_conf = $this->mariadbConf;
+            $this->database->image = $this->image;
+            $this->database->ports_mappings = $this->portsMappings;
+            $this->database->is_public = $this->isPublic;
+            $this->database->public_port = $this->publicPort;
+            $this->database->is_log_drain_enabled = $this->isLogDrainEnabled;
+            $this->database->custom_docker_run_options = $this->customDockerRunOptions;
+            $this->database->enable_ssl = $this->enableSsl;
+            $this->database->save();
+
+            $this->db_url = $this->database->internal_db_url;
+            $this->db_url_public = $this->database->external_db_url;
+        } else {
+            $this->name = $this->database->name;
+            $this->description = $this->database->description;
+            $this->mariadbRootPassword = $this->database->mariadb_root_password;
+            $this->mariadbUser = $this->database->mariadb_user;
+            $this->mariadbPassword = $this->database->mariadb_password;
+            $this->mariadbDatabase = $this->database->mariadb_database;
+            $this->mariadbConf = $this->database->mariadb_conf;
+            $this->image = $this->database->image;
+            $this->portsMappings = $this->database->ports_mappings;
+            $this->isPublic = $this->database->is_public;
+            $this->publicPort = $this->database->public_port;
+            $this->isLogDrainEnabled = $this->database->is_log_drain_enabled;
+            $this->customDockerRunOptions = $this->database->custom_docker_run_options;
+            $this->enableSsl = $this->database->enable_ssl;
+            $this->db_url = $this->database->internal_db_url;
+            $this->db_url_public = $this->database->external_db_url;
         }
     }
 
@@ -114,12 +189,12 @@ class General extends Component
             $this->authorize('update', $this->database);
 
             if (! $this->server->isLogDrainEnabled()) {
-                $this->database->is_log_drain_enabled = false;
+                $this->isLogDrainEnabled = false;
                 $this->dispatch('error', 'Log drain is not enabled on the server. Please enable it first.');
 
                 return;
             }
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'Database updated.');
             $this->dispatch('success', 'You need to restart the service for the changes to take effect.');
         } catch (Exception $e) {
@@ -132,11 +207,10 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            if (str($this->database->public_port)->isEmpty()) {
-                $this->database->public_port = null;
+            if (str($this->publicPort)->isEmpty()) {
+                $this->publicPort = null;
             }
-            $this->validate();
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'Database updated.');
         } catch (Exception $e) {
             return handleError($e, $this);
@@ -154,16 +228,16 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            if ($this->database->is_public && ! $this->database->public_port) {
+            if ($this->isPublic && ! $this->publicPort) {
                 $this->dispatch('error', 'Public port is required.');
-                $this->database->is_public = false;
+                $this->isPublic = false;
 
                 return;
             }
-            if ($this->database->is_public) {
+            if ($this->isPublic) {
                 if (! str($this->database->status)->startsWith('running')) {
                     $this->dispatch('error', 'Database must be started to be publicly accessible.');
-                    $this->database->is_public = false;
+                    $this->isPublic = false;
 
                     return;
                 }
@@ -173,10 +247,9 @@ class General extends Component
                 StopDatabaseProxy::run($this->database);
                 $this->dispatch('success', 'Database is no longer publicly accessible.');
             }
-            $this->db_url_public = $this->database->external_db_url;
-            $this->database->save();
+            $this->syncData(true);
         } catch (\Throwable $e) {
-            $this->database->is_public = ! $this->database->is_public;
+            $this->isPublic = ! $this->isPublic;
 
             return handleError($e, $this);
         }
@@ -187,7 +260,7 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'SSL configuration updated.');
         } catch (Exception $e) {
             return handleError($e, $this);
@@ -207,7 +280,7 @@ class General extends Component
                 return;
             }
 
-            $caCert = SslCertificate::where('server_id', $existingCert->server_id)->where('is_ca_certificate', true)->first();
+            $caCert = $this->server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             SslHelper::generateSslCertificate(
                 commonName: $existingCert->common_name,
@@ -231,6 +304,7 @@ class General extends Component
     public function refresh(): void
     {
         $this->database->refresh();
+        $this->syncData();
     }
 
     public function render()

app/Livewire/Project/Database/Mongodb/General.php

@@ -6,7 +6,6 @@ use App\Actions\Database\StartDatabaseProxy;
 use App\Actions\Database\StopDatabaseProxy;
 use App\Helpers\SslHelper;
 use App\Models\Server;
-use App\Models\SslCertificate;
 use App\Models\StandaloneMongodb;
 use App\Support\ValidationPatterns;
 use Carbon\Carbon;
@@ -19,12 +18,38 @@ class General extends Component
 {
     use AuthorizesRequests;
 
-    protected $listeners = ['refresh'];
-
-    public Server $server;
+    public ?Server $server = null;
 
     public StandaloneMongodb $database;
 
+    public string $name;
+
+    public ?string $description = null;
+
+    public ?string $mongoConf = null;
+
+    public string $mongoInitdbRootUsername;
+
+    public string $mongoInitdbRootPassword;
+
+    public string $mongoInitdbDatabase;
+
+    public string $image;
+
+    public ?string $portsMappings = null;
+
+    public ?bool $isPublic = null;
+
+    public ?int $publicPort = null;
+
+    public bool $isLogDrainEnabled = false;
+
+    public ?string $customDockerRunOptions = null;
+
+    public bool $enableSsl = false;
+
+    public ?string $sslMode = null;
+
     public ?string $db_url = null;
 
     public ?string $db_url_public = null;
@@ -37,27 +62,26 @@ class General extends Component
 
         return [
             "echo-private:user.{$userId},DatabaseStatusChanged" => '$refresh',
-            'refresh' => '$refresh',
         ];
     }
 
     protected function rules(): array
     {
         return [
-            'database.name' => ValidationPatterns::nameRules(),
-            'database.description' => ValidationPatterns::descriptionRules(),
-            'database.mongo_conf' => 'nullable',
-            'database.mongo_initdb_root_username' => 'required',
-            'database.mongo_initdb_root_password' => 'required',
-            'database.mongo_initdb_database' => 'required',
-            'database.image' => 'required',
-            'database.ports_mappings' => 'nullable',
-            'database.is_public' => 'nullable|boolean',
-            'database.public_port' => 'nullable|integer',
-            'database.is_log_drain_enabled' => 'nullable|boolean',
-            'database.custom_docker_run_options' => 'nullable',
-            'database.enable_ssl' => 'boolean',
-            'database.ssl_mode' => 'nullable|string|in:allow,prefer,require,verify-full',
+            'name' => ValidationPatterns::nameRules(),
+            'description' => ValidationPatterns::descriptionRules(),
+            'mongoConf' => 'nullable',
+            'mongoInitdbRootUsername' => 'required',
+            'mongoInitdbRootPassword' => 'required',
+            'mongoInitdbDatabase' => 'required',
+            'image' => 'required',
+            'portsMappings' => 'nullable',
+            'isPublic' => 'nullable|boolean',
+            'publicPort' => 'nullable|integer',
+            'isLogDrainEnabled' => 'nullable|boolean',
+            'customDockerRunOptions' => 'nullable',
+            'enableSsl' => 'boolean',
+            'sslMode' => 'nullable|string|in:allow,prefer,require,verify-full',
         ];
     }
 
@@ -66,45 +90,96 @@ class General extends Component
         return array_merge(
             ValidationPatterns::combinedMessages(),
             [
-                'database.name.required' => 'The Name field is required.',
-                'database.name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
-                'database.description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
-                'database.mongo_initdb_root_username.required' => 'The Root Username field is required.',
-                'database.mongo_initdb_root_password.required' => 'The Root Password field is required.',
-                'database.mongo_initdb_database.required' => 'The MongoDB Database field is required.',
-                'database.image.required' => 'The Docker Image field is required.',
-                'database.public_port.integer' => 'The Public Port must be an integer.',
-                'database.ssl_mode.in' => 'The SSL Mode must be one of: allow, prefer, require, verify-full.',
+                'name.required' => 'The Name field is required.',
+                'name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
+                'description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
+                'mongoInitdbRootUsername.required' => 'The Root Username field is required.',
+                'mongoInitdbRootPassword.required' => 'The Root Password field is required.',
+                'mongoInitdbDatabase.required' => 'The MongoDB Database field is required.',
+                'image.required' => 'The Docker Image field is required.',
+                'publicPort.integer' => 'The Public Port must be an integer.',
+                'sslMode.in' => 'The SSL Mode must be one of: allow, prefer, require, verify-full.',
             ]
         );
     }
 
     protected $validationAttributes = [
-        'database.name' => 'Name',
-        'database.description' => 'Description',
-        'database.mongo_conf' => 'Mongo Configuration',
-        'database.mongo_initdb_root_username' => 'Root Username',
-        'database.mongo_initdb_root_password' => 'Root Password',
-        'database.mongo_initdb_database' => 'Database',
-        'database.image' => 'Image',
-        'database.ports_mappings' => 'Port Mapping',
-        'database.is_public' => 'Is Public',
-        'database.public_port' => 'Public Port',
-        'database.custom_docker_run_options' => 'Custom Docker Run Options',
-        'database.enable_ssl' => 'Enable SSL',
-        'database.ssl_mode' => 'SSL Mode',
+        'name' => 'Name',
+        'description' => 'Description',
+        'mongoConf' => 'Mongo Configuration',
+        'mongoInitdbRootUsername' => 'Root Username',
+        'mongoInitdbRootPassword' => 'Root Password',
+        'mongoInitdbDatabase' => 'Database',
+        'image' => 'Image',
+        'portsMappings' => 'Port Mapping',
+        'isPublic' => 'Is Public',
+        'publicPort' => 'Public Port',
+        'customDockerRunOptions' => 'Custom Docker Run Options',
+        'enableSsl' => 'Enable SSL',
+        'sslMode' => 'SSL Mode',
     ];
 
     public function mount()
     {
-        $this->db_url = $this->database->internal_db_url;
-        $this->db_url_public = $this->database->external_db_url;
-        $this->server = data_get($this->database, 'destination.server');
+        try {
+            $this->authorize('view', $this->database);
+            $this->syncData();
+            $this->server = data_get($this->database, 'destination.server');
+            if (! $this->server) {
+                $this->dispatch('error', 'Database destination server is not configured.');
 
-        $existingCert = $this->database->sslCertificates()->first();
+                return;
+            }
 
-        if ($existingCert) {
-            $this->certificateValidUntil = $existingCert->valid_until;
+            $existingCert = $this->database->sslCertificates()->first();
+
+            if ($existingCert) {
+                $this->certificateValidUntil = $existingCert->valid_until;
+            }
+        } catch (Exception $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function syncData(bool $toModel = false)
+    {
+        if ($toModel) {
+            $this->validate();
+            $this->database->name = $this->name;
+            $this->database->description = $this->description;
+            $this->database->mongo_conf = $this->mongoConf;
+            $this->database->mongo_initdb_root_username = $this->mongoInitdbRootUsername;
+            $this->database->mongo_initdb_root_password = $this->mongoInitdbRootPassword;
+            $this->database->mongo_initdb_database = $this->mongoInitdbDatabase;
+            $this->database->image = $this->image;
+            $this->database->ports_mappings = $this->portsMappings;
+            $this->database->is_public = $this->isPublic;
+            $this->database->public_port = $this->publicPort;
+            $this->database->is_log_drain_enabled = $this->isLogDrainEnabled;
+            $this->database->custom_docker_run_options = $this->customDockerRunOptions;
+            $this->database->enable_ssl = $this->enableSsl;
+            $this->database->ssl_mode = $this->sslMode;
+            $this->database->save();
+
+            $this->db_url = $this->database->internal_db_url;
+            $this->db_url_public = $this->database->external_db_url;
+        } else {
+            $this->name = $this->database->name;
+            $this->description = $this->database->description;
+            $this->mongoConf = $this->database->mongo_conf;
+            $this->mongoInitdbRootUsername = $this->database->mongo_initdb_root_username;
+            $this->mongoInitdbRootPassword = $this->database->mongo_initdb_root_password;
+            $this->mongoInitdbDatabase = $this->database->mongo_initdb_database;
+            $this->image = $this->database->image;
+            $this->portsMappings = $this->database->ports_mappings;
+            $this->isPublic = $this->database->is_public;
+            $this->publicPort = $this->database->public_port;
+            $this->isLogDrainEnabled = $this->database->is_log_drain_enabled;
+            $this->customDockerRunOptions = $this->database->custom_docker_run_options;
+            $this->enableSsl = $this->database->enable_ssl;
+            $this->sslMode = $this->database->ssl_mode;
+            $this->db_url = $this->database->internal_db_url;
+            $this->db_url_public = $this->database->external_db_url;
         }
     }
 
@@ -114,12 +189,12 @@ class General extends Component
             $this->authorize('update', $this->database);
 
             if (! $this->server->isLogDrainEnabled()) {
-                $this->database->is_log_drain_enabled = false;
+                $this->isLogDrainEnabled = false;
                 $this->dispatch('error', 'Log drain is not enabled on the server. Please enable it first.');
 
                 return;
             }
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'Database updated.');
             $this->dispatch('success', 'You need to restart the service for the changes to take effect.');
         } catch (Exception $e) {
@@ -132,14 +207,13 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            if (str($this->database->public_port)->isEmpty()) {
-                $this->database->public_port = null;
+            if (str($this->publicPort)->isEmpty()) {
+                $this->publicPort = null;
             }
-            if (str($this->database->mongo_conf)->isEmpty()) {
-                $this->database->mongo_conf = null;
+            if (str($this->mongoConf)->isEmpty()) {
+                $this->mongoConf = null;
             }
-            $this->validate();
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'Database updated.');
         } catch (Exception $e) {
             return handleError($e, $this);
@@ -157,16 +231,16 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            if ($this->database->is_public && ! $this->database->public_port) {
+            if ($this->isPublic && ! $this->publicPort) {
                 $this->dispatch('error', 'Public port is required.');
-                $this->database->is_public = false;
+                $this->isPublic = false;
 
                 return;
             }
-            if ($this->database->is_public) {
+            if ($this->isPublic) {
                 if (! str($this->database->status)->startsWith('running')) {
                     $this->dispatch('error', 'Database must be started to be publicly accessible.');
-                    $this->database->is_public = false;
+                    $this->isPublic = false;
 
                     return;
                 }
@@ -176,16 +250,15 @@ class General extends Component
                 StopDatabaseProxy::run($this->database);
                 $this->dispatch('success', 'Database is no longer publicly accessible.');
             }
-            $this->db_url_public = $this->database->external_db_url;
-            $this->database->save();
+            $this->syncData(true);
         } catch (\Throwable $e) {
-            $this->database->is_public = ! $this->database->is_public;
+            $this->isPublic = ! $this->isPublic;
 
             return handleError($e, $this);
         }
     }
 
-    public function updatedDatabaseSslMode()
+    public function updatedSslMode()
     {
         $this->instantSaveSSL();
     }
@@ -195,7 +268,7 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'SSL configuration updated.');
         } catch (Exception $e) {
             return handleError($e, $this);
@@ -215,7 +288,7 @@ class General extends Component
                 return;
             }
 
-            $caCert = SslCertificate::where('server_id', $existingCert->server_id)->where('is_ca_certificate', true)->first();
+            $caCert = $this->server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             SslHelper::generateSslCertificate(
                 commonName: $existingCert->common_name,
@@ -239,6 +312,7 @@ class General extends Component
     public function refresh(): void
     {
         $this->database->refresh();
+        $this->syncData();
     }
 
     public function render()

app/Livewire/Project/Database/Mysql/General.php

@@ -6,7 +6,6 @@ use App\Actions\Database\StartDatabaseProxy;
 use App\Actions\Database\StopDatabaseProxy;
 use App\Helpers\SslHelper;
 use App\Models\Server;
-use App\Models\SslCertificate;
 use App\Models\StandaloneMysql;
 use App\Support\ValidationPatterns;
 use Carbon\Carbon;
@@ -19,11 +18,39 @@ class General extends Component
 {
     use AuthorizesRequests;
 
-    protected $listeners = ['refresh'];
-
     public StandaloneMysql $database;
 
-    public Server $server;
+    public ?Server $server = null;
+
+    public string $name;
+
+    public ?string $description = null;
+
+    public string $mysqlRootPassword;
+
+    public string $mysqlUser;
+
+    public string $mysqlPassword;
+
+    public string $mysqlDatabase;
+
+    public ?string $mysqlConf = null;
+
+    public string $image;
+
+    public ?string $portsMappings = null;
+
+    public ?bool $isPublic = null;
+
+    public ?int $publicPort = null;
+
+    public bool $isLogDrainEnabled = false;
+
+    public ?string $customDockerRunOptions = null;
+
+    public bool $enableSsl = false;
+
+    public ?string $sslMode = null;
 
     public ?string $db_url = null;
 
@@ -37,28 +64,27 @@ class General extends Component
 
         return [
             "echo-private:user.{$userId},DatabaseStatusChanged" => '$refresh',
-            'refresh' => '$refresh',
         ];
     }
 
     protected function rules(): array
     {
         return [
-            'database.name' => ValidationPatterns::nameRules(),
-            'database.description' => ValidationPatterns::descriptionRules(),
-            'database.mysql_root_password' => 'required',
-            'database.mysql_user' => 'required',
-            'database.mysql_password' => 'required',
-            'database.mysql_database' => 'required',
-            'database.mysql_conf' => 'nullable',
-            'database.image' => 'required',
-            'database.ports_mappings' => 'nullable',
-            'database.is_public' => 'nullable|boolean',
-            'database.public_port' => 'nullable|integer',
-            'database.is_log_drain_enabled' => 'nullable|boolean',
-            'database.custom_docker_run_options' => 'nullable',
-            'database.enable_ssl' => 'boolean',
-            'database.ssl_mode' => 'nullable|string|in:PREFERRED,REQUIRED,VERIFY_CA,VERIFY_IDENTITY',
+            'name' => ValidationPatterns::nameRules(),
+            'description' => ValidationPatterns::descriptionRules(),
+            'mysqlRootPassword' => 'required',
+            'mysqlUser' => 'required',
+            'mysqlPassword' => 'required',
+            'mysqlDatabase' => 'required',
+            'mysqlConf' => 'nullable',
+            'image' => 'required',
+            'portsMappings' => 'nullable',
+            'isPublic' => 'nullable|boolean',
+            'publicPort' => 'nullable|integer',
+            'isLogDrainEnabled' => 'nullable|boolean',
+            'customDockerRunOptions' => 'nullable',
+            'enableSsl' => 'boolean',
+            'sslMode' => 'nullable|string|in:PREFERRED,REQUIRED,VERIFY_CA,VERIFY_IDENTITY',
         ];
     }
 
@@ -67,47 +93,100 @@ class General extends Component
         return array_merge(
             ValidationPatterns::combinedMessages(),
             [
-                'database.name.required' => 'The Name field is required.',
-                'database.name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
-                'database.description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
-                'database.mysql_root_password.required' => 'The Root Password field is required.',
-                'database.mysql_user.required' => 'The MySQL User field is required.',
-                'database.mysql_password.required' => 'The MySQL Password field is required.',
-                'database.mysql_database.required' => 'The MySQL Database field is required.',
-                'database.image.required' => 'The Docker Image field is required.',
-                'database.public_port.integer' => 'The Public Port must be an integer.',
-                'database.ssl_mode.in' => 'The SSL Mode must be one of: PREFERRED, REQUIRED, VERIFY_CA, VERIFY_IDENTITY.',
+                'name.required' => 'The Name field is required.',
+                'name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
+                'description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
+                'mysqlRootPassword.required' => 'The Root Password field is required.',
+                'mysqlUser.required' => 'The MySQL User field is required.',
+                'mysqlPassword.required' => 'The MySQL Password field is required.',
+                'mysqlDatabase.required' => 'The MySQL Database field is required.',
+                'image.required' => 'The Docker Image field is required.',
+                'publicPort.integer' => 'The Public Port must be an integer.',
+                'sslMode.in' => 'The SSL Mode must be one of: PREFERRED, REQUIRED, VERIFY_CA, VERIFY_IDENTITY.',
             ]
         );
     }
 
     protected $validationAttributes = [
-        'database.name' => 'Name',
-        'database.description' => 'Description',
-        'database.mysql_root_password' => 'Root Password',
-        'database.mysql_user' => 'User',
-        'database.mysql_password' => 'Password',
-        'database.mysql_database' => 'Database',
-        'database.mysql_conf' => 'MySQL Configuration',
-        'database.image' => 'Image',
-        'database.ports_mappings' => 'Port Mapping',
-        'database.is_public' => 'Is Public',
-        'database.public_port' => 'Public Port',
-        'database.custom_docker_run_options' => 'Custom Docker Run Options',
-        'database.enable_ssl' => 'Enable SSL',
-        'database.ssl_mode' => 'SSL Mode',
+        'name' => 'Name',
+        'description' => 'Description',
+        'mysqlRootPassword' => 'Root Password',
+        'mysqlUser' => 'User',
+        'mysqlPassword' => 'Password',
+        'mysqlDatabase' => 'Database',
+        'mysqlConf' => 'MySQL Configuration',
+        'image' => 'Image',
+        'portsMappings' => 'Port Mapping',
+        'isPublic' => 'Is Public',
+        'publicPort' => 'Public Port',
+        'customDockerRunOptions' => 'Custom Docker Run Options',
+        'enableSsl' => 'Enable SSL',
+        'sslMode' => 'SSL Mode',
     ];
 
     public function mount()
     {
-        $this->db_url = $this->database->internal_db_url;
-        $this->db_url_public = $this->database->external_db_url;
-        $this->server = data_get($this->database, 'destination.server');
+        try {
+            $this->authorize('view', $this->database);
+            $this->syncData();
+            $this->server = data_get($this->database, 'destination.server');
+            if (! $this->server) {
+                $this->dispatch('error', 'Database destination server is not configured.');
 
-        $existingCert = $this->database->sslCertificates()->first();
+                return;
+            }
 
-        if ($existingCert) {
-            $this->certificateValidUntil = $existingCert->valid_until;
+            $existingCert = $this->database->sslCertificates()->first();
+
+            if ($existingCert) {
+                $this->certificateValidUntil = $existingCert->valid_until;
+            }
+        } catch (Exception $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function syncData(bool $toModel = false)
+    {
+        if ($toModel) {
+            $this->validate();
+            $this->database->name = $this->name;
+            $this->database->description = $this->description;
+            $this->database->mysql_root_password = $this->mysqlRootPassword;
+            $this->database->mysql_user = $this->mysqlUser;
+            $this->database->mysql_password = $this->mysqlPassword;
+            $this->database->mysql_database = $this->mysqlDatabase;
+            $this->database->mysql_conf = $this->mysqlConf;
+            $this->database->image = $this->image;
+            $this->database->ports_mappings = $this->portsMappings;
+            $this->database->is_public = $this->isPublic;
+            $this->database->public_port = $this->publicPort;
+            $this->database->is_log_drain_enabled = $this->isLogDrainEnabled;
+            $this->database->custom_docker_run_options = $this->customDockerRunOptions;
+            $this->database->enable_ssl = $this->enableSsl;
+            $this->database->ssl_mode = $this->sslMode;
+            $this->database->save();
+
+            $this->db_url = $this->database->internal_db_url;
+            $this->db_url_public = $this->database->external_db_url;
+        } else {
+            $this->name = $this->database->name;
+            $this->description = $this->database->description;
+            $this->mysqlRootPassword = $this->database->mysql_root_password;
+            $this->mysqlUser = $this->database->mysql_user;
+            $this->mysqlPassword = $this->database->mysql_password;
+            $this->mysqlDatabase = $this->database->mysql_database;
+            $this->mysqlConf = $this->database->mysql_conf;
+            $this->image = $this->database->image;
+            $this->portsMappings = $this->database->ports_mappings;
+            $this->isPublic = $this->database->is_public;
+            $this->publicPort = $this->database->public_port;
+            $this->isLogDrainEnabled = $this->database->is_log_drain_enabled;
+            $this->customDockerRunOptions = $this->database->custom_docker_run_options;
+            $this->enableSsl = $this->database->enable_ssl;
+            $this->sslMode = $this->database->ssl_mode;
+            $this->db_url = $this->database->internal_db_url;
+            $this->db_url_public = $this->database->external_db_url;
         }
     }
 
@@ -117,12 +196,12 @@ class General extends Component
             $this->authorize('update', $this->database);
 
             if (! $this->server->isLogDrainEnabled()) {
-                $this->database->is_log_drain_enabled = false;
+                $this->isLogDrainEnabled = false;
                 $this->dispatch('error', 'Log drain is not enabled on the server. Please enable it first.');
 
                 return;
             }
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'Database updated.');
             $this->dispatch('success', 'You need to restart the service for the changes to take effect.');
         } catch (Exception $e) {
@@ -135,11 +214,10 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            if (str($this->database->public_port)->isEmpty()) {
-                $this->database->public_port = null;
+            if (str($this->publicPort)->isEmpty()) {
+                $this->publicPort = null;
             }
-            $this->validate();
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'Database updated.');
         } catch (Exception $e) {
             return handleError($e, $this);
@@ -157,16 +235,16 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            if ($this->database->is_public && ! $this->database->public_port) {
+            if ($this->isPublic && ! $this->publicPort) {
                 $this->dispatch('error', 'Public port is required.');
-                $this->database->is_public = false;
+                $this->isPublic = false;
 
                 return;
             }
-            if ($this->database->is_public) {
+            if ($this->isPublic) {
                 if (! str($this->database->status)->startsWith('running')) {
                     $this->dispatch('error', 'Database must be started to be publicly accessible.');
-                    $this->database->is_public = false;
+                    $this->isPublic = false;
 
                     return;
                 }
@@ -176,16 +254,15 @@ class General extends Component
                 StopDatabaseProxy::run($this->database);
                 $this->dispatch('success', 'Database is no longer publicly accessible.');
             }
-            $this->db_url_public = $this->database->external_db_url;
-            $this->database->save();
+            $this->syncData(true);
         } catch (\Throwable $e) {
-            $this->database->is_public = ! $this->database->is_public;
+            $this->isPublic = ! $this->isPublic;
 
             return handleError($e, $this);
         }
     }
 
-    public function updatedDatabaseSslMode()
+    public function updatedSslMode()
     {
         $this->instantSaveSSL();
     }
@@ -195,7 +272,7 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'SSL configuration updated.');
         } catch (Exception $e) {
             return handleError($e, $this);
@@ -215,7 +292,7 @@ class General extends Component
                 return;
             }
 
-            $caCert = SslCertificate::where('server_id', $existingCert->server_id)->where('is_ca_certificate', true)->first();
+            $caCert = $this->server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             SslHelper::generateSslCertificate(
                 commonName: $existingCert->common_name,
@@ -239,6 +316,7 @@ class General extends Component
     public function refresh(): void
     {
         $this->database->refresh();
+        $this->syncData();
     }
 
     public function render()

app/Livewire/Project/Database/Postgresql/General.php

@@ -6,7 +6,6 @@ use App\Actions\Database\StartDatabaseProxy;
 use App\Actions\Database\StopDatabaseProxy;
 use App\Helpers\SslHelper;
 use App\Models\Server;
-use App\Models\SslCertificate;
 use App\Models\StandalonePostgresql;
 use App\Support\ValidationPatterns;
 use Carbon\Carbon;
@@ -21,7 +20,41 @@ class General extends Component
 
     public StandalonePostgresql $database;
 
-    public Server $server;
+    public ?Server $server = null;
+
+    public string $name;
+
+    public ?string $description = null;
+
+    public string $postgresUser;
+
+    public string $postgresPassword;
+
+    public string $postgresDb;
+
+    public ?string $postgresInitdbArgs = null;
+
+    public ?string $postgresHostAuthMethod = null;
+
+    public ?string $postgresConf = null;
+
+    public ?array $initScripts = null;
+
+    public string $image;
+
+    public ?string $portsMappings = null;
+
+    public ?bool $isPublic = null;
+
+    public ?int $publicPort = null;
+
+    public bool $isLogDrainEnabled = false;
+
+    public ?string $customDockerRunOptions = null;
+
+    public bool $enableSsl = false;
+
+    public ?string $sslMode = null;
 
     public string $new_filename;
 
@@ -39,7 +72,6 @@ class General extends Component
 
         return [
             "echo-private:user.{$userId},DatabaseStatusChanged" => '$refresh',
-            'refresh' => '$refresh',
             'save_init_script',
             'delete_init_script',
         ];
@@ -48,23 +80,23 @@ class General extends Component
     protected function rules(): array
     {
         return [
-            'database.name' => ValidationPatterns::nameRules(),
-            'database.description' => ValidationPatterns::descriptionRules(),
-            'database.postgres_user' => 'required',
-            'database.postgres_password' => 'required',
-            'database.postgres_db' => 'required',
-            'database.postgres_initdb_args' => 'nullable',
-            'database.postgres_host_auth_method' => 'nullable',
-            'database.postgres_conf' => 'nullable',
-            'database.init_scripts' => 'nullable',
-            'database.image' => 'required',
-            'database.ports_mappings' => 'nullable',
-            'database.is_public' => 'nullable|boolean',
-            'database.public_port' => 'nullable|integer',
-            'database.is_log_drain_enabled' => 'nullable|boolean',
-            'database.custom_docker_run_options' => 'nullable',
-            'database.enable_ssl' => 'boolean',
-            'database.ssl_mode' => 'nullable|string|in:allow,prefer,require,verify-ca,verify-full',
+            'name' => ValidationPatterns::nameRules(),
+            'description' => ValidationPatterns::descriptionRules(),
+            'postgresUser' => 'required',
+            'postgresPassword' => 'required',
+            'postgresDb' => 'required',
+            'postgresInitdbArgs' => 'nullable',
+            'postgresHostAuthMethod' => 'nullable',
+            'postgresConf' => 'nullable',
+            'initScripts' => 'nullable',
+            'image' => 'required',
+            'portsMappings' => 'nullable',
+            'isPublic' => 'nullable|boolean',
+            'publicPort' => 'nullable|integer',
+            'isLogDrainEnabled' => 'nullable|boolean',
+            'customDockerRunOptions' => 'nullable',
+            'enableSsl' => 'boolean',
+            'sslMode' => 'nullable|string|in:allow,prefer,require,verify-ca,verify-full',
         ];
     }
 
@@ -73,48 +105,105 @@ class General extends Component
         return array_merge(
             ValidationPatterns::combinedMessages(),
             [
-                'database.name.required' => 'The Name field is required.',
-                'database.name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
-                'database.description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
-                'database.postgres_user.required' => 'The Postgres User field is required.',
-                'database.postgres_password.required' => 'The Postgres Password field is required.',
-                'database.postgres_db.required' => 'The Postgres Database field is required.',
-                'database.image.required' => 'The Docker Image field is required.',
-                'database.public_port.integer' => 'The Public Port must be an integer.',
-                'database.ssl_mode.in' => 'The SSL Mode must be one of: allow, prefer, require, verify-ca, verify-full.',
+                'name.required' => 'The Name field is required.',
+                'name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
+                'description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
+                'postgresUser.required' => 'The Postgres User field is required.',
+                'postgresPassword.required' => 'The Postgres Password field is required.',
+                'postgresDb.required' => 'The Postgres Database field is required.',
+                'image.required' => 'The Docker Image field is required.',
+                'publicPort.integer' => 'The Public Port must be an integer.',
+                'sslMode.in' => 'The SSL Mode must be one of: allow, prefer, require, verify-ca, verify-full.',
             ]
         );
     }
 
     protected $validationAttributes = [
-        'database.name' => 'Name',
-        'database.description' => 'Description',
-        'database.postgres_user' => 'Postgres User',
-        'database.postgres_password' => 'Postgres Password',
-        'database.postgres_db' => 'Postgres DB',
-        'database.postgres_initdb_args' => 'Postgres Initdb Args',
-        'database.postgres_host_auth_method' => 'Postgres Host Auth Method',
-        'database.postgres_conf' => 'Postgres Configuration',
-        'database.init_scripts' => 'Init Scripts',
-        'database.image' => 'Image',
-        'database.ports_mappings' => 'Port Mapping',
-        'database.is_public' => 'Is Public',
-        'database.public_port' => 'Public Port',
-        'database.custom_docker_run_options' => 'Custom Docker Run Options',
-        'database.enable_ssl' => 'Enable SSL',
-        'database.ssl_mode' => 'SSL Mode',
+        'name' => 'Name',
+        'description' => 'Description',
+        'postgresUser' => 'Postgres User',
+        'postgresPassword' => 'Postgres Password',
+        'postgresDb' => 'Postgres DB',
+        'postgresInitdbArgs' => 'Postgres Initdb Args',
+        'postgresHostAuthMethod' => 'Postgres Host Auth Method',
+        'postgresConf' => 'Postgres Configuration',
+        'initScripts' => 'Init Scripts',
+        'image' => 'Image',
+        'portsMappings' => 'Port Mapping',
+        'isPublic' => 'Is Public',
+        'publicPort' => 'Public Port',
+        'customDockerRunOptions' => 'Custom Docker Run Options',
+        'enableSsl' => 'Enable SSL',
+        'sslMode' => 'SSL Mode',
     ];
 
     public function mount()
     {
-        $this->db_url = $this->database->internal_db_url;
-        $this->db_url_public = $this->database->external_db_url;
-        $this->server = data_get($this->database, 'destination.server');
+        try {
+            $this->authorize('view', $this->database);
+            $this->syncData();
+            $this->server = data_get($this->database, 'destination.server');
+            if (! $this->server) {
+                $this->dispatch('error', 'Database destination server is not configured.');
 
-        $existingCert = $this->database->sslCertificates()->first();
+                return;
+            }
 
-        if ($existingCert) {
-            $this->certificateValidUntil = $existingCert->valid_until;
+            $existingCert = $this->database->sslCertificates()->first();
+
+            if ($existingCert) {
+                $this->certificateValidUntil = $existingCert->valid_until;
+            }
+        } catch (Exception $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function syncData(bool $toModel = false)
+    {
+        if ($toModel) {
+            $this->validate();
+            $this->database->name = $this->name;
+            $this->database->description = $this->description;
+            $this->database->postgres_user = $this->postgresUser;
+            $this->database->postgres_password = $this->postgresPassword;
+            $this->database->postgres_db = $this->postgresDb;
+            $this->database->postgres_initdb_args = $this->postgresInitdbArgs;
+            $this->database->postgres_host_auth_method = $this->postgresHostAuthMethod;
+            $this->database->postgres_conf = $this->postgresConf;
+            $this->database->init_scripts = $this->initScripts;
+            $this->database->image = $this->image;
+            $this->database->ports_mappings = $this->portsMappings;
+            $this->database->is_public = $this->isPublic;
+            $this->database->public_port = $this->publicPort;
+            $this->database->is_log_drain_enabled = $this->isLogDrainEnabled;
+            $this->database->custom_docker_run_options = $this->customDockerRunOptions;
+            $this->database->enable_ssl = $this->enableSsl;
+            $this->database->ssl_mode = $this->sslMode;
+            $this->database->save();
+
+            $this->db_url = $this->database->internal_db_url;
+            $this->db_url_public = $this->database->external_db_url;
+        } else {
+            $this->name = $this->database->name;
+            $this->description = $this->database->description;
+            $this->postgresUser = $this->database->postgres_user;
+            $this->postgresPassword = $this->database->postgres_password;
+            $this->postgresDb = $this->database->postgres_db;
+            $this->postgresInitdbArgs = $this->database->postgres_initdb_args;
+            $this->postgresHostAuthMethod = $this->database->postgres_host_auth_method;
+            $this->postgresConf = $this->database->postgres_conf;
+            $this->initScripts = $this->database->init_scripts;
+            $this->image = $this->database->image;
+            $this->portsMappings = $this->database->ports_mappings;
+            $this->isPublic = $this->database->is_public;
+            $this->publicPort = $this->database->public_port;
+            $this->isLogDrainEnabled = $this->database->is_log_drain_enabled;
+            $this->customDockerRunOptions = $this->database->custom_docker_run_options;
+            $this->enableSsl = $this->database->enable_ssl;
+            $this->sslMode = $this->database->ssl_mode;
+            $this->db_url = $this->database->internal_db_url;
+            $this->db_url_public = $this->database->external_db_url;
         }
     }
 
@@ -124,12 +213,12 @@ class General extends Component
             $this->authorize('update', $this->database);
 
             if (! $this->server->isLogDrainEnabled()) {
-                $this->database->is_log_drain_enabled = false;
+                $this->isLogDrainEnabled = false;
                 $this->dispatch('error', 'Log drain is not enabled on the server. Please enable it first.');
 
                 return;
             }
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'Database updated.');
             $this->dispatch('success', 'You need to restart the service for the changes to take effect.');
         } catch (Exception $e) {
@@ -137,7 +226,7 @@ class General extends Component
         }
     }
 
-    public function updatedDatabaseSslMode()
+    public function updatedSslMode()
     {
         $this->instantSaveSSL();
     }
@@ -147,10 +236,8 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'SSL configuration updated.');
-            $this->db_url = $this->database->internal_db_url;
-            $this->db_url_public = $this->database->external_db_url;
         } catch (Exception $e) {
             return handleError($e, $this);
         }
@@ -169,7 +256,7 @@ class General extends Component
                 return;
             }
 
-            $caCert = SslCertificate::where('server_id', $existingCert->server_id)->where('is_ca_certificate', true)->first();
+            $caCert = $this->server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             SslHelper::generateSslCertificate(
                 commonName: $existingCert->common_name,
@@ -195,16 +282,16 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            if ($this->database->is_public && ! $this->database->public_port) {
+            if ($this->isPublic && ! $this->publicPort) {
                 $this->dispatch('error', 'Public port is required.');
-                $this->database->is_public = false;
+                $this->isPublic = false;
 
                 return;
             }
-            if ($this->database->is_public) {
+            if ($this->isPublic) {
                 if (! str($this->database->status)->startsWith('running')) {
                     $this->dispatch('error', 'Database must be started to be publicly accessible.');
-                    $this->database->is_public = false;
+                    $this->isPublic = false;
 
                     return;
                 }
@@ -214,10 +301,9 @@ class General extends Component
                 StopDatabaseProxy::run($this->database);
                 $this->dispatch('success', 'Database is no longer publicly accessible.');
             }
-            $this->db_url_public = $this->database->external_db_url;
-            $this->database->save();
+            $this->syncData(true);
         } catch (\Throwable $e) {
-            $this->database->is_public = ! $this->database->is_public;
+            $this->isPublic = ! $this->isPublic;
 
             return handleError($e, $this);
         }
@@ -227,7 +313,7 @@ class General extends Component
     {
         $this->authorize('update', $this->database);
 
-        $initScripts = collect($this->database->init_scripts ?? []);
+        $initScripts = collect($this->initScripts ?? []);
 
         $existingScript = $initScripts->firstWhere('filename', $script['filename']);
         $oldScript = $initScripts->firstWhere('index', $script['index']);
@@ -263,7 +349,7 @@ class General extends Component
             $initScripts->push($script);
         }
 
-        $this->database->init_scripts = $initScripts->values()
+        $this->initScripts = $initScripts->values()
             ->map(function ($item, $index) {
                 $item['index'] = $index;
 
@@ -271,7 +357,7 @@ class General extends Component
             })
             ->all();
 
-        $this->database->save();
+        $this->syncData(true);
         $this->dispatch('success', 'Init script saved and updated.');
     }
 
@@ -279,7 +365,7 @@ class General extends Component
     {
         $this->authorize('update', $this->database);
 
-        $collection = collect($this->database->init_scripts);
+        $collection = collect($this->initScripts);
         $found = $collection->firstWhere('filename', $script['filename']);
         if ($found) {
             $container_name = $this->database->uuid;
@@ -304,8 +390,8 @@ class General extends Component
                 })
                 ->all();
 
-            $this->database->init_scripts = $updatedScripts;
-            $this->database->save();
+            $this->initScripts = $updatedScripts;
+            $this->syncData(true);
             $this->dispatch('refresh')->self();
             $this->dispatch('success', 'Init script deleted from the database and the server.');
         }
@@ -319,23 +405,23 @@ class General extends Component
             'new_filename' => 'required|string',
             'new_content' => 'required|string',
         ]);
-        $found = collect($this->database->init_scripts)->firstWhere('filename', $this->new_filename);
+        $found = collect($this->initScripts)->firstWhere('filename', $this->new_filename);
         if ($found) {
             $this->dispatch('error', 'Filename already exists.');
 
             return;
         }
-        if (! isset($this->database->init_scripts)) {
-            $this->database->init_scripts = [];
+        if (! isset($this->initScripts)) {
+            $this->initScripts = [];
         }
-        $this->database->init_scripts = array_merge($this->database->init_scripts, [
+        $this->initScripts = array_merge($this->initScripts, [
             [
-                'index' => count($this->database->init_scripts),
+                'index' => count($this->initScripts),
                 'filename' => $this->new_filename,
                 'content' => $this->new_content,
             ],
         ]);
-        $this->database->save();
+        $this->syncData(true);
         $this->dispatch('success', 'Init script added.');
         $this->new_content = '';
         $this->new_filename = '';
@@ -346,11 +432,10 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            if (str($this->database->public_port)->isEmpty()) {
-                $this->database->public_port = null;
+            if (str($this->publicPort)->isEmpty()) {
+                $this->publicPort = null;
             }
-            $this->validate();
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'Database updated.');
         } catch (Exception $e) {
             return handleError($e, $this);

app/Livewire/Project/Database/Redis/General.php

@@ -6,7 +6,6 @@ use App\Actions\Database\StartDatabaseProxy;
 use App\Actions\Database\StopDatabaseProxy;
 use App\Helpers\SslHelper;
 use App\Models\Server;
-use App\Models\SslCertificate;
 use App\Models\StandaloneRedis;
 use App\Support\ValidationPatterns;
 use Carbon\Carbon;
@@ -19,19 +18,39 @@ class General extends Component
 {
     use AuthorizesRequests;
 
-    public Server $server;
+    public ?Server $server = null;
 
     public StandaloneRedis $database;
 
-    public string $redis_username;
+    public string $name;
 
-    public ?string $redis_password;
+    public ?string $description = null;
 
-    public string $redis_version;
+    public ?string $redisConf = null;
 
-    public ?string $db_url = null;
+    public string $image;
 
-    public ?string $db_url_public = null;
+    public ?string $portsMappings = null;
+
+    public ?bool $isPublic = null;
+
+    public ?int $publicPort = null;
+
+    public bool $isLogDrainEnabled = false;
+
+    public ?string $customDockerRunOptions = null;
+
+    public string $redisUsername;
+
+    public string $redisPassword;
+
+    public string $redisVersion;
+
+    public ?string $dbUrl = null;
+
+    public ?string $dbUrlPublic = null;
+
+    public bool $enableSsl = false;
 
     public ?Carbon $certificateValidUntil = null;
 
@@ -42,25 +61,24 @@ class General extends Component
         return [
             "echo-private:user.{$userId},DatabaseStatusChanged" => '$refresh',
             'envsUpdated' => 'refresh',
-            'refresh',
         ];
     }
 
     protected function rules(): array
     {
         return [
-            'database.name' => ValidationPatterns::nameRules(),
-            'database.description' => ValidationPatterns::descriptionRules(),
-            'database.redis_conf' => 'nullable',
-            'database.image' => 'required',
-            'database.ports_mappings' => 'nullable',
-            'database.is_public' => 'nullable|boolean',
-            'database.public_port' => 'nullable|integer',
-            'database.is_log_drain_enabled' => 'nullable|boolean',
-            'database.custom_docker_run_options' => 'nullable',
-            'redis_username' => 'required',
-            'redis_password' => 'required',
-            'database.enable_ssl' => 'boolean',
+            'name' => ValidationPatterns::nameRules(),
+            'description' => ValidationPatterns::descriptionRules(),
+            'redisConf' => 'nullable',
+            'image' => 'required',
+            'portsMappings' => 'nullable',
+            'isPublic' => 'nullable|boolean',
+            'publicPort' => 'nullable|integer',
+            'isLogDrainEnabled' => 'nullable|boolean',
+            'customDockerRunOptions' => 'nullable',
+            'redisUsername' => 'required',
+            'redisPassword' => 'required',
+            'enableSsl' => 'boolean',
         ];
     }
 
@@ -69,39 +87,87 @@ class General extends Component
         return array_merge(
             ValidationPatterns::combinedMessages(),
             [
-                'database.name.required' => 'The Name field is required.',
-                'database.name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
-                'database.description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
-                'database.image.required' => 'The Docker Image field is required.',
-                'database.public_port.integer' => 'The Public Port must be an integer.',
-                'redis_username.required' => 'The Redis Username field is required.',
-                'redis_password.required' => 'The Redis Password field is required.',
+                'name.required' => 'The Name field is required.',
+                'name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
+                'description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
+                'image.required' => 'The Docker Image field is required.',
+                'publicPort.integer' => 'The Public Port must be an integer.',
+                'redisUsername.required' => 'The Redis Username field is required.',
+                'redisPassword.required' => 'The Redis Password field is required.',
             ]
         );
     }
 
     protected $validationAttributes = [
-        'database.name' => 'Name',
-        'database.description' => 'Description',
-        'database.redis_conf' => 'Redis Configuration',
-        'database.image' => 'Image',
-        'database.ports_mappings' => 'Port Mapping',
-        'database.is_public' => 'Is Public',
-        'database.public_port' => 'Public Port',
-        'database.custom_docker_run_options' => 'Custom Docker Options',
-        'redis_username' => 'Redis Username',
-        'redis_password' => 'Redis Password',
-        'database.enable_ssl' => 'Enable SSL',
+        'name' => 'Name',
+        'description' => 'Description',
+        'redisConf' => 'Redis Configuration',
+        'image' => 'Image',
+        'portsMappings' => 'Port Mapping',
+        'isPublic' => 'Is Public',
+        'publicPort' => 'Public Port',
+        'customDockerRunOptions' => 'Custom Docker Options',
+        'redisUsername' => 'Redis Username',
+        'redisPassword' => 'Redis Password',
+        'enableSsl' => 'Enable SSL',
     ];
 
     public function mount()
     {
-        $this->server = data_get($this->database, 'destination.server');
-        $this->refreshView();
-        $existingCert = $this->database->sslCertificates()->first();
+        try {
+            $this->authorize('view', $this->database);
+            $this->syncData();
+            $this->server = data_get($this->database, 'destination.server');
+            if (! $this->server) {
+                $this->dispatch('error', 'Database destination server is not configured.');
 
-        if ($existingCert) {
-            $this->certificateValidUntil = $existingCert->valid_until;
+                return;
+            }
+
+            $existingCert = $this->database->sslCertificates()->first();
+
+            if ($existingCert) {
+                $this->certificateValidUntil = $existingCert->valid_until;
+            }
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function syncData(bool $toModel = false)
+    {
+        if ($toModel) {
+            $this->validate();
+            $this->database->name = $this->name;
+            $this->database->description = $this->description;
+            $this->database->redis_conf = $this->redisConf;
+            $this->database->image = $this->image;
+            $this->database->ports_mappings = $this->portsMappings;
+            $this->database->is_public = $this->isPublic;
+            $this->database->public_port = $this->publicPort;
+            $this->database->is_log_drain_enabled = $this->isLogDrainEnabled;
+            $this->database->custom_docker_run_options = $this->customDockerRunOptions;
+            $this->database->enable_ssl = $this->enableSsl;
+            $this->database->save();
+
+            $this->dbUrl = $this->database->internal_db_url;
+            $this->dbUrlPublic = $this->database->external_db_url;
+        } else {
+            $this->name = $this->database->name;
+            $this->description = $this->database->description;
+            $this->redisConf = $this->database->redis_conf;
+            $this->image = $this->database->image;
+            $this->portsMappings = $this->database->ports_mappings;
+            $this->isPublic = $this->database->is_public;
+            $this->publicPort = $this->database->public_port;
+            $this->isLogDrainEnabled = $this->database->is_log_drain_enabled;
+            $this->customDockerRunOptions = $this->database->custom_docker_run_options;
+            $this->enableSsl = $this->database->enable_ssl;
+            $this->dbUrl = $this->database->internal_db_url;
+            $this->dbUrlPublic = $this->database->external_db_url;
+            $this->redisVersion = $this->database->getRedisVersion();
+            $this->redisUsername = $this->database->redis_username;
+            $this->redisPassword = $this->database->redis_password;
         }
     }
 
@@ -111,12 +177,12 @@ class General extends Component
             $this->authorize('update', $this->database);
 
             if (! $this->server->isLogDrainEnabled()) {
-                $this->database->is_log_drain_enabled = false;
+                $this->isLogDrainEnabled = false;
                 $this->dispatch('error', 'Log drain is not enabled on the server. Please enable it first.');
 
                 return;
             }
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'Database updated.');
             $this->dispatch('success', 'You need to restart the service for the changes to take effect.');
         } catch (Exception $e) {
@@ -129,20 +195,19 @@ class General extends Component
         try {
             $this->authorize('manageEnvironment', $this->database);
 
-            $this->validate();
+            $this->syncData(true);
 
-            if (version_compare($this->redis_version, '6.0', '>=')) {
+            if (version_compare($this->redisVersion, '6.0', '>=')) {
                 $this->database->runtime_environment_variables()->updateOrCreate(
                     ['key' => 'REDIS_USERNAME'],
-                    ['value' => $this->redis_username, 'resourceable_id' => $this->database->id]
+                    ['value' => $this->redisUsername, 'resourceable_id' => $this->database->id]
                 );
             }
             $this->database->runtime_environment_variables()->updateOrCreate(
                 ['key' => 'REDIS_PASSWORD'],
-                ['value' => $this->redis_password, 'resourceable_id' => $this->database->id]
+                ['value' => $this->redisPassword, 'resourceable_id' => $this->database->id]
             );
 
-            $this->database->save();
             $this->dispatch('success', 'Database updated.');
         } catch (Exception $e) {
             return handleError($e, $this);
@@ -156,16 +221,16 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            if ($this->database->is_public && ! $this->database->public_port) {
+            if ($this->isPublic && ! $this->publicPort) {
                 $this->dispatch('error', 'Public port is required.');
-                $this->database->is_public = false;
+                $this->isPublic = false;
 
                 return;
             }
-            if ($this->database->is_public) {
+            if ($this->isPublic) {
                 if (! str($this->database->status)->startsWith('running')) {
                     $this->dispatch('error', 'Database must be started to be publicly accessible.');
-                    $this->database->is_public = false;
+                    $this->isPublic = false;
 
                     return;
                 }
@@ -175,10 +240,11 @@ class General extends Component
                 StopDatabaseProxy::run($this->database);
                 $this->dispatch('success', 'Database is no longer publicly accessible.');
             }
-            $this->db_url_public = $this->database->external_db_url;
-            $this->database->save();
+            $this->dbUrlPublic = $this->database->external_db_url;
+            $this->syncData(true);
         } catch (\Throwable $e) {
-            $this->database->is_public = ! $this->database->is_public;
+            $this->isPublic = ! $this->isPublic;
+            $this->syncData(true);
 
             return handleError($e, $this);
         }
@@ -189,7 +255,7 @@ class General extends Component
         try {
             $this->authorize('update', $this->database);
 
-            $this->database->save();
+            $this->syncData(true);
             $this->dispatch('success', 'SSL configuration updated.');
         } catch (Exception $e) {
             return handleError($e, $this);
@@ -209,7 +275,7 @@ class General extends Component
                 return;
             }
 
-            $caCert = SslCertificate::where('server_id', $existingCert->server_id)->where('is_ca_certificate', true)->first();
+            $caCert = $this->server->sslCertificates()->where('is_ca_certificate', true)->first();
 
             SslHelper::generateSslCertificate(
                 commonName: $existingCert->commonName,
@@ -233,16 +299,7 @@ class General extends Component
     public function refresh(): void
     {
         $this->database->refresh();
-        $this->refreshView();
-    }
-
-    private function refreshView()
-    {
-        $this->db_url = $this->database->internal_db_url;
-        $this->db_url_public = $this->database->external_db_url;
-        $this->redis_version = $this->database->getRedisVersion();
-        $this->redis_username = $this->database->redis_username;
-        $this->redis_password = $this->database->redis_password;
+        $this->syncData();
     }
 
     public function render()

app/Livewire/Project/Index.php

@@ -18,12 +18,7 @@ class Index extends Component
     public function mount()
     {
         $this->private_keys = PrivateKey::ownedByCurrentTeam()->get();
-        $this->projects = Project::ownedByCurrentTeam()->get()->map(function ($project) {
-            $project->settingsRoute = route('project.edit', ['project_uuid' => $project->uuid]);
-            $project->canUpdate = auth()->user()->can('update', $project);
-
-            return $project;
-        });
+        $this->projects = Project::ownedByCurrentTeam()->get();
         $this->servers = Server::ownedByCurrentTeam()->count();
     }
 
@@ -31,11 +26,4 @@ class Index extends Component
     {
         return view('livewire.project.index');
     }
-
-    public function navigateToProject($projectUuid)
-    {
-        $project = collect($this->projects)->firstWhere('uuid', $projectUuid);
-
-        return $this->redirect($project->navigateTo(), navigate: false);
-    }
 }

app/Livewire/Project/New/DockerCompose.php

@@ -37,6 +37,10 @@ class DockerCompose extends Component
                 'dockerComposeRaw' => 'required',
             ]);
             $this->dockerComposeRaw = Yaml::dump(Yaml::parse($this->dockerComposeRaw), 10, 2, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK);
+
+            // Validate for command injection BEFORE saving to database
+            validateDockerComposeForInjection($this->dockerComposeRaw);
+
             $project = Project::where('uuid', $this->parameters['project_uuid'])->first();
             $environment = $project->load(['environments'])->environments->where('uuid', $this->parameters['environment_uuid'])->first();
 

app/Livewire/Project/New/DockerImage.php

@@ -12,7 +12,11 @@ use Visus\Cuid2\Cuid2;
 
 class DockerImage extends Component
 {
-    public string $dockerImage = '';
+    public string $imageName = '';
+
+    public string $imageTag = '';
+
+    public string $imageSha256 = '';
 
     public array $parameters;
 
@@ -24,14 +28,88 @@ class DockerImage extends Component
         $this->query = request()->query();
     }
 
+    /**
+     * Auto-parse image name when user pastes a complete Docker image reference
+     * Examples:
+     * - nginx:stable-alpine3.21-perl@sha256:4e272eef...
+     * - ghcr.io/user/app:v1.2.3
+     * - nginx@sha256:abc123...
+     */
+    public function updatedImageName(): void
+    {
+        if (empty($this->imageName)) {
+            return;
+        }
+
+        // Don't auto-parse if user has already manually filled tag or sha256 fields
+        if (! empty($this->imageTag) || ! empty($this->imageSha256)) {
+            return;
+        }
+
+        // Only auto-parse if the image name contains a tag (:) or digest (@)
+        if (! str_contains($this->imageName, ':') && ! str_contains($this->imageName, '@')) {
+            return;
+        }
+
+        try {
+            $parser = new DockerImageParser;
+            $parser->parse($this->imageName);
+
+            // Extract the base image name (without tag/digest)
+            $baseImageName = $parser->getFullImageNameWithoutTag();
+
+            // Only update if parsing resulted in different base name
+            // This prevents unnecessary updates when user types just the name
+            if ($baseImageName !== $this->imageName) {
+                if ($parser->isImageHash()) {
+                    // It's a SHA256 digest (takes priority over tag)
+                    $this->imageSha256 = $parser->getTag();
+                    $this->imageTag = '';
+                } elseif ($parser->getTag() !== 'latest' || str_contains($this->imageName, ':')) {
+                    // It's a regular tag (only set if not default 'latest' or explicitly specified)
+                    $this->imageTag = $parser->getTag();
+                    $this->imageSha256 = '';
+                }
+
+                // Update imageName to just the base name
+                $this->imageName = $baseImageName;
+            }
+        } catch (\Exception $e) {
+            // If parsing fails, leave the image name as-is
+            // User will see validation error on submit
+        }
+    }
+
     public function submit()
     {
         $this->validate([
-            'dockerImage' => 'required',
+            'imageName' => ['required', 'string'],
+            'imageTag' => ['nullable', 'string', 'regex:/^[a-z0-9][a-z0-9._-]*$/i'],
+            'imageSha256' => ['nullable', 'string', 'regex:/^[a-f0-9]{64}$/i'],
         ]);
 
+        // Validate that either tag or sha256 is provided, but not both
+        if ($this->imageTag && $this->imageSha256) {
+            $this->addError('imageTag', 'Provide either a tag or SHA256 digest, not both.');
+            $this->addError('imageSha256', 'Provide either a tag or SHA256 digest, not both.');
+
+            return;
+        }
+
+        // Build the full Docker image string
+        if ($this->imageSha256) {
+            // Strip 'sha256:' prefix if user pasted it
+            $sha256Hash = preg_replace('/^sha256:/i', '', trim($this->imageSha256));
+            $dockerImage = $this->imageName.'@sha256:'.$sha256Hash;
+        } elseif ($this->imageTag) {
+            $dockerImage = $this->imageName.':'.$this->imageTag;
+        } else {
+            $dockerImage = $this->imageName.':latest';
+        }
+
+        // Parse using DockerImageParser to normalize the image reference
         $parser = new DockerImageParser;
-        $parser->parse($this->dockerImage);
+        $parser->parse($dockerImage);
 
         $destination_uuid = $this->query['destination'];
         $destination = StandaloneDocker::where('uuid', $destination_uuid)->first();
@@ -45,6 +123,16 @@ class DockerImage extends Component
 
         $project = Project::where('uuid', $this->parameters['project_uuid'])->first();
         $environment = $project->load(['environments'])->environments->where('uuid', $this->parameters['environment_uuid'])->first();
+
+        // Append @sha256 to image name if using digest and not already present
+        $imageName = $parser->getFullImageNameWithoutTag();
+        if ($parser->isImageHash() && ! str_ends_with($imageName, '@sha256')) {
+            $imageName .= '@sha256';
+        }
+
+        // Determine the image tag based on whether it's a hash or regular tag
+        $imageTag = $parser->isImageHash() ? 'sha256-'.$parser->getTag() : $parser->getTag();
+
         $application = Application::create([
             'name' => 'docker-image-'.new Cuid2,
             'repository_project_id' => 0,
@@ -52,8 +140,8 @@ class DockerImage extends Component
             'git_branch' => 'main',
             'build_pack' => 'dockerimage',
             'ports_exposes' => 80,
-            'docker_registry_image_name' => $parser->getFullImageNameWithoutTag(),
-            'docker_registry_image_tag' => $parser->getTag(),
+            'docker_registry_image_name' => $imageName,
+            'docker_registry_image_tag' => $imageTag,
             'environment_id' => $environment->id,
             'destination_id' => $destination->id,
             'destination_type' => $destination_class,

app/Livewire/Project/New/GithubPrivateRepository.php

@@ -55,7 +55,7 @@ class GithubPrivateRepository extends Component
     public ?string $publish_directory = null;
 
     // In case of docker compose
-    public ?string $base_directory = null;
+    public ?string $base_directory = '/';
 
     public ?string $docker_compose_location = '/docker-compose.yaml';
     // End of docker compose
@@ -198,6 +198,7 @@ class GithubPrivateRepository extends Component
                 'build_pack' => $this->build_pack,
                 'ports_exposes' => $this->port,
                 'publish_directory' => $this->publish_directory,
+                'base_directory' => $this->base_directory,
                 'environment_id' => $environment->id,
                 'destination_id' => $destination->id,
                 'destination_type' => $destination_class,
@@ -212,7 +213,6 @@ class GithubPrivateRepository extends Component
             }
             if ($this->build_pack === 'dockercompose') {
                 $application['docker_compose_location'] = $this->docker_compose_location;
-                $application['base_directory'] = $this->base_directory;
             }
             $fqdn = generateUrl(server: $destination->server, random: $application->uuid);
             $application->fqdn = $fqdn;

app/Livewire/Project/New/GithubPrivateRepositoryDeployKey.php

@@ -90,7 +90,7 @@ class GithubPrivateRepositoryDeployKey extends Component
     public function mount()
     {
         if (isDev()) {
-            $this->repository_url = 'https://github.com/coollabsio/coolify-examples';
+            $this->repository_url = 'https://github.com/coollabsio/coolify-examples/tree/v4.x';
         }
         $this->parameters = get_route_parameters();
         $this->query = request()->query();

app/Livewire/Project/New/PublicGitRepository.php

@@ -100,7 +100,7 @@ class PublicGitRepository extends Component
     public function mount()
     {
         if (isDev()) {
-            $this->repository_url = 'https://github.com/coollabsio/coolify-examples';
+            $this->repository_url = 'https://github.com/coollabsio/coolify-examples/tree/v4.x';
             $this->port = 3000;
         }
         $this->parameters = get_route_parameters();
@@ -176,13 +176,16 @@ class PublicGitRepository extends Component
                     str($this->repository_url)->startsWith('http://')) &&
                 ! str($this->repository_url)->endsWith('.git') &&
                 (! str($this->repository_url)->contains('github.com') ||
-                    ! str($this->repository_url)->contains('git.sr.ht'))
+                    ! str($this->repository_url)->contains('git.sr.ht')) &&
+                    ! str($this->repository_url)->contains('tangled')
             ) {
+
                 $this->repository_url = $this->repository_url.'.git';
             }
             if (str($this->repository_url)->contains('github.com') && str($this->repository_url)->endsWith('.git')) {
                 $this->repository_url = str($this->repository_url)->beforeLast('.git')->value();
             }
+
         } catch (\Throwable $e) {
             return handleError($e, $this);
         }
@@ -190,6 +193,9 @@ class PublicGitRepository extends Component
             $this->branchFound = false;
             $this->getGitSource();
             $this->getBranch();
+            if (str($this->repository_url)->contains('tangled')) {
+                $this->git_branch = 'master';
+            }
             $this->selectedBranch = $this->git_branch;
         } catch (\Throwable $e) {
             if ($this->rate_limit_remaining == 0) {

app/Livewire/Project/Resource/Create.php

@@ -81,7 +81,7 @@ class Create extends Component
                         'destination_id' => $destination->id,
                         'destination_type' => $destination->getMorphClass(),
                     ];
-                    if ($oneClickServiceName === 'cloudflared') {
+                    if ($oneClickServiceName === 'cloudflared' || $oneClickServiceName === 'pgadmin') {
                         data_set($service_payload, 'connect_to_docker_network', true);
                     }
                     $service = Service::create($service_payload);

app/Livewire/Project/Service/Configuration.php

@@ -33,6 +33,8 @@ class Configuration extends Component
 
         return [
             "echo-private:team.{$teamId},ServiceChecked" => 'serviceChecked',
+            'refreshServices' => 'refreshServices',
+            'refresh' => 'refreshServices',
         ];
     }
 

app/Livewire/Project/Service/Database.php

@@ -24,16 +24,30 @@ class Database extends Component
 
     public $parameters;
 
+    public ?string $humanName = null;
+
+    public ?string $description = null;
+
+    public ?string $image = null;
+
+    public bool $excludeFromStatus = false;
+
+    public ?int $publicPort = null;
+
+    public bool $isPublic = false;
+
+    public bool $isLogDrainEnabled = false;
+
     protected $listeners = ['refreshFileStorages'];
 
     protected $rules = [
-        'database.human_name' => 'nullable',
-        'database.description' => 'nullable',
-        'database.image' => 'required',
-        'database.exclude_from_status' => 'required|boolean',
-        'database.public_port' => 'nullable|integer',
-        'database.is_public' => 'required|boolean',
-        'database.is_log_drain_enabled' => 'required|boolean',
+        'humanName' => 'nullable',
+        'description' => 'nullable',
+        'image' => 'required',
+        'excludeFromStatus' => 'required|boolean',
+        'publicPort' => 'nullable|integer',
+        'isPublic' => 'required|boolean',
+        'isLogDrainEnabled' => 'required|boolean',
     ];
 
     public function render()
@@ -50,11 +64,33 @@ class Database extends Component
                 $this->db_url_public = $this->database->getServiceDatabaseUrl();
             }
             $this->refreshFileStorages();
+            $this->syncData(false);
         } catch (\Throwable $e) {
             return handleError($e, $this);
         }
     }
 
+    private function syncData(bool $toModel = false): void
+    {
+        if ($toModel) {
+            $this->database->human_name = $this->humanName;
+            $this->database->description = $this->description;
+            $this->database->image = $this->image;
+            $this->database->exclude_from_status = $this->excludeFromStatus;
+            $this->database->public_port = $this->publicPort;
+            $this->database->is_public = $this->isPublic;
+            $this->database->is_log_drain_enabled = $this->isLogDrainEnabled;
+        } else {
+            $this->humanName = $this->database->human_name;
+            $this->description = $this->database->description;
+            $this->image = $this->database->image;
+            $this->excludeFromStatus = $this->database->exclude_from_status ?? false;
+            $this->publicPort = $this->database->public_port;
+            $this->isPublic = $this->database->is_public ?? false;
+            $this->isLogDrainEnabled = $this->database->is_log_drain_enabled ?? false;
+        }
+    }
+
     public function delete($password)
     {
         try {
@@ -92,7 +128,7 @@ class Database extends Component
         try {
             $this->authorize('update', $this->database);
             if (! $this->database->service->destination->server->isLogDrainEnabled()) {
-                $this->database->is_log_drain_enabled = false;
+                $this->isLogDrainEnabled = false;
                 $this->dispatch('error', 'Log drain is not enabled on the server. Please enable it first.');
 
                 return;
@@ -145,15 +181,17 @@ class Database extends Component
     {
         try {
             $this->authorize('update', $this->database);
-            if ($this->database->is_public && ! $this->database->public_port) {
+            if ($this->isPublic && ! $this->publicPort) {
                 $this->dispatch('error', 'Public port is required.');
-                $this->database->is_public = false;
+                $this->isPublic = false;
 
                 return;
             }
+            $this->syncData(true);
             if ($this->database->is_public) {
                 if (! str($this->database->status)->startsWith('running')) {
                     $this->dispatch('error', 'Database must be started to be publicly accessible.');
+                    $this->isPublic = false;
                     $this->database->is_public = false;
 
                     return;
@@ -182,7 +220,10 @@ class Database extends Component
         try {
             $this->authorize('update', $this->database);
             $this->validate();
+            $this->syncData(true);
             $this->database->save();
+            $this->database->refresh();
+            $this->syncData(false);
             updateCompose($this->database);
             $this->dispatch('success', 'Database saved.');
         } catch (\Throwable $e) {

app/Livewire/Project/Service/EditCompose.php

@@ -11,6 +11,12 @@ class EditCompose extends Component
 
     public $serviceId;
 
+    public ?string $dockerComposeRaw = null;
+
+    public ?string $dockerCompose = null;
+
+    public bool $isContainerLabelEscapeEnabled = false;
+
     protected $listeners = [
         'refreshEnvs',
         'envsUpdated',
@@ -18,30 +24,45 @@ class EditCompose extends Component
     ];
 
     protected $rules = [
-        'service.docker_compose_raw' => 'required',
-        'service.docker_compose' => 'required',
-        'service.is_container_label_escape_enabled' => 'required',
+        'dockerComposeRaw' => 'required',
+        'dockerCompose' => 'required',
+        'isContainerLabelEscapeEnabled' => 'required',
     ];
 
     public function envsUpdated()
     {
-        $this->dispatch('saveCompose', $this->service->docker_compose_raw);
+        $this->dispatch('saveCompose', $this->dockerComposeRaw);
         $this->refreshEnvs();
     }
 
     public function refreshEnvs()
     {
         $this->service = Service::ownedByCurrentTeam()->find($this->serviceId);
+        $this->syncData(false);
     }
 
     public function mount()
     {
         $this->service = Service::ownedByCurrentTeam()->find($this->serviceId);
+        $this->syncData(false);
+    }
+
+    private function syncData(bool $toModel = false): void
+    {
+        if ($toModel) {
+            $this->service->docker_compose_raw = $this->dockerComposeRaw;
+            $this->service->docker_compose = $this->dockerCompose;
+            $this->service->is_container_label_escape_enabled = $this->isContainerLabelEscapeEnabled;
+        } else {
+            $this->dockerComposeRaw = $this->service->docker_compose_raw;
+            $this->dockerCompose = $this->service->docker_compose;
+            $this->isContainerLabelEscapeEnabled = $this->service->is_container_label_escape_enabled ?? false;
+        }
     }
 
     public function validateCompose()
     {
-        $isValid = validateComposeFile($this->service->docker_compose_raw, $this->service->server_id);
+        $isValid = validateComposeFile($this->dockerComposeRaw, $this->service->server_id);
         if ($isValid !== 'OK') {
             $this->dispatch('error', "Invalid docker-compose file.\n$isValid");
         } else {
@@ -52,16 +73,17 @@ class EditCompose extends Component
     public function saveEditedCompose()
     {
         $this->dispatch('info', 'Saving new docker compose...');
-        $this->dispatch('saveCompose', $this->service->docker_compose_raw);
+        $this->dispatch('saveCompose', $this->dockerComposeRaw);
         $this->dispatch('refreshStorages');
     }
 
     public function instantSave()
     {
         $this->validate([
-            'service.is_container_label_escape_enabled' => 'required',
+            'isContainerLabelEscapeEnabled' => 'required',
         ]);
-        $this->service->save(['is_container_label_escape_enabled' => $this->service->is_container_label_escape_enabled]);
+        $this->syncData(true);
+        $this->service->save(['is_container_label_escape_enabled' => $this->isContainerLabelEscapeEnabled]);
         $this->dispatch('success', 'Service updated successfully');
     }
 

app/Livewire/Project/Service/EditDomain.php

@@ -2,12 +2,14 @@
 
 namespace App\Livewire\Project\Service;
 
+use App\Livewire\Concerns\SynchronizesModelData;
 use App\Models\ServiceApplication;
 use Livewire\Component;
 use Spatie\Url\Url;
 
 class EditDomain extends Component
 {
+    use SynchronizesModelData;
     public $applicationId;
 
     public ServiceApplication $application;
@@ -18,14 +20,24 @@ class EditDomain extends Component
 
     public $forceSaveDomains = false;
 
+    public ?string $fqdn = null;
+
     protected $rules = [
-        'application.fqdn' => 'nullable',
-        'application.required_fqdn' => 'required|boolean',
+        'fqdn' => 'nullable',
     ];
 
     public function mount()
     {
-        $this->application = ServiceApplication::find($this->applicationId);
+        $this->application = ServiceApplication::query()->findOrFail($this->applicationId);
+        $this->authorize('view', $this->application);
+        $this->syncFromModel();
+    }
+
+    protected function getModelBindings(): array
+    {
+        return [
+            'fqdn' => 'application.fqdn',
+        ];
     }
 
     public function confirmDomainUsage()
@@ -38,19 +50,22 @@ class EditDomain extends Component
     public function submit()
     {
         try {
-            $this->application->fqdn = str($this->application->fqdn)->replaceEnd(',', '')->trim();
-            $this->application->fqdn = str($this->application->fqdn)->replaceStart(',', '')->trim();
-            $this->application->fqdn = str($this->application->fqdn)->trim()->explode(',')->map(function ($domain) {
+            $this->authorize('update', $this->application);
+            $this->fqdn = str($this->fqdn)->replaceEnd(',', '')->trim()->toString();
+            $this->fqdn = str($this->fqdn)->replaceStart(',', '')->trim()->toString();
+            $domains = str($this->fqdn)->trim()->explode(',')->map(function ($domain) {
                 $domain = trim($domain);
                 Url::fromString($domain, ['http', 'https']);
 
                 return str($domain)->lower();
             });
-            $this->application->fqdn = $this->application->fqdn->unique()->implode(',');
-            $warning = sslipDomainWarning($this->application->fqdn);
+            $this->fqdn = $domains->unique()->implode(',');
+            $warning = sslipDomainWarning($this->fqdn);
             if ($warning) {
                 $this->dispatch('warning', __('warning.sslipdomain'));
             }
+            // Sync to model for domain conflict check
+            $this->syncToModel();
             // Check for domain conflicts if not forcing save
             if (! $this->forceSaveDomains) {
                 $result = checkDomainUsage(resource: $this->application);
@@ -67,17 +82,21 @@ class EditDomain extends Component
 
             $this->validate();
             $this->application->save();
+            $this->application->refresh();
+            $this->syncFromModel();
             updateCompose($this->application);
             if (str($this->application->fqdn)->contains(',')) {
                 $this->dispatch('warning', 'Some services do not support multiple domains, which can lead to problems and is NOT RECOMMENDED.<br><br>Only use multiple domains if you know what you are doing.');
             }
             $this->application->service->parse();
             $this->dispatch('refresh');
+            $this->dispatch('refreshServices');
             $this->dispatch('configurationChanged');
         } catch (\Throwable $e) {
             $originalFqdn = $this->application->getOriginal('fqdn');
             if ($originalFqdn !== $this->application->fqdn) {
                 $this->application->fqdn = $originalFqdn;
+                $this->syncFromModel();
             }
 
             return handleError($e, $this);

app/Livewire/Project/Service/FileStorage.php

@@ -2,6 +2,7 @@
 
 namespace App\Livewire\Project\Service;
 
+use App\Livewire\Concerns\SynchronizesModelData;
 use App\Models\Application;
 use App\Models\InstanceSettings;
 use App\Models\LocalFileVolume;
@@ -22,7 +23,7 @@ use Livewire\Component;
 
 class FileStorage extends Component
 {
-    use AuthorizesRequests;
+    use AuthorizesRequests, SynchronizesModelData;
 
     public LocalFileVolume $fileStorage;
 
@@ -34,12 +35,18 @@ class FileStorage extends Component
 
     public bool $permanently_delete = true;
 
+    public bool $isReadOnly = false;
+
+    public ?string $content = null;
+
+    public bool $isBasedOnGit = false;
+
     protected $rules = [
         'fileStorage.is_directory' => 'required',
         'fileStorage.fs_path' => 'required',
         'fileStorage.mount_path' => 'required',
-        'fileStorage.content' => 'nullable',
-        'fileStorage.is_based_on_git' => 'required|boolean',
+        'content' => 'nullable',
+        'isBasedOnGit' => 'required|boolean',
     ];
 
     public function mount()
@@ -52,6 +59,17 @@ class FileStorage extends Component
             $this->workdir = null;
             $this->fs_path = $this->fileStorage->fs_path;
         }
+
+        $this->isReadOnly = $this->fileStorage->isReadOnlyVolume();
+        $this->syncFromModel();
+    }
+
+    protected function getModelBindings(): array
+    {
+        return [
+            'content' => 'fileStorage.content',
+            'isBasedOnGit' => 'fileStorage.is_based_on_git',
+        ];
     }
 
     public function convertToDirectory()
@@ -78,6 +96,7 @@ class FileStorage extends Component
             $this->authorize('update', $this->resource);
 
             $this->fileStorage->loadStorageOnServer();
+            $this->syncFromModel();
             $this->dispatch('success', 'File storage loaded from server.');
         } catch (\Throwable $e) {
             return handleError($e, $this);
@@ -144,14 +163,16 @@ class FileStorage extends Component
         try {
             $this->validate();
             if ($this->fileStorage->is_directory) {
-                $this->fileStorage->content = null;
+                $this->content = null;
             }
+            $this->syncToModel();
             $this->fileStorage->save();
             $this->fileStorage->saveStorageOnServer();
             $this->dispatch('success', 'File updated.');
         } catch (\Throwable $e) {
             $this->fileStorage->setRawAttributes($original);
             $this->fileStorage->save();
+            $this->syncFromModel();
 
             return handleError($e, $this);
         }

app/Livewire/Project/Service/Heading.php

@@ -54,6 +54,11 @@ class Heading extends Component
         }
     }
 
+    public function manualCheckStatus()
+    {
+        $this->checkStatus();
+    }
+
     public function serviceChecked()
     {
         try {

app/Livewire/Project/Service/ServiceApplicationView.php

@@ -2,6 +2,7 @@
 
 namespace App\Livewire\Project\Service;
 
+use App\Livewire\Concerns\SynchronizesModelData;
 use App\Models\InstanceSettings;
 use App\Models\ServiceApplication;
 use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
@@ -14,6 +15,7 @@ use Spatie\Url\Url;
 class ServiceApplicationView extends Component
 {
     use AuthorizesRequests;
+    use SynchronizesModelData;
 
     public ServiceApplication $application;
 
@@ -29,16 +31,32 @@ class ServiceApplicationView extends Component
 
     public $forceSaveDomains = false;
 
+    public ?string $humanName = null;
+
+    public ?string $description = null;
+
+    public ?string $fqdn = null;
+
+    public ?string $image = null;
+
+    public bool $excludeFromStatus = false;
+
+    public bool $isLogDrainEnabled = false;
+
+    public bool $isGzipEnabled = false;
+
+    public bool $isStripprefixEnabled = false;
+
     protected $rules = [
-        'application.human_name' => 'nullable',
-        'application.description' => 'nullable',
-        'application.fqdn' => 'nullable',
-        'application.image' => 'string|nullable',
-        'application.exclude_from_status' => 'required|boolean',
+        'humanName' => 'nullable',
+        'description' => 'nullable',
+        'fqdn' => 'nullable',
+        'image' => 'string|nullable',
+        'excludeFromStatus' => 'required|boolean',
         'application.required_fqdn' => 'required|boolean',
-        'application.is_log_drain_enabled' => 'nullable|boolean',
-        'application.is_gzip_enabled' => 'nullable|boolean',
-        'application.is_stripprefix_enabled' => 'nullable|boolean',
+        'isLogDrainEnabled' => 'nullable|boolean',
+        'isGzipEnabled' => 'nullable|boolean',
+        'isStripprefixEnabled' => 'nullable|boolean',
     ];
 
     public function instantSave()
@@ -56,11 +74,12 @@ class ServiceApplicationView extends Component
         try {
             $this->authorize('update', $this->application);
             if (! $this->application->service->destination->server->isLogDrainEnabled()) {
-                $this->application->is_log_drain_enabled = false;
+                $this->isLogDrainEnabled = false;
                 $this->dispatch('error', 'Log drain is not enabled on the server. Please enable it first.');
 
                 return;
             }
+            $this->syncToModel();
             $this->application->save();
             $this->dispatch('success', 'You need to restart the service for the changes to take effect.');
         } catch (\Throwable $e) {
@@ -95,11 +114,26 @@ class ServiceApplicationView extends Component
         try {
             $this->parameters = get_route_parameters();
             $this->authorize('view', $this->application);
+            $this->syncFromModel();
         } catch (\Throwable $e) {
             return handleError($e, $this);
         }
     }
 
+    protected function getModelBindings(): array
+    {
+        return [
+            'humanName' => 'application.human_name',
+            'description' => 'application.description',
+            'fqdn' => 'application.fqdn',
+            'image' => 'application.image',
+            'excludeFromStatus' => 'application.exclude_from_status',
+            'isLogDrainEnabled' => 'application.is_log_drain_enabled',
+            'isGzipEnabled' => 'application.is_gzip_enabled',
+            'isStripprefixEnabled' => 'application.is_stripprefix_enabled',
+        ];
+    }
+
     public function convertToDatabase()
     {
         try {
@@ -146,19 +180,21 @@ class ServiceApplicationView extends Component
     {
         try {
             $this->authorize('update', $this->application);
-            $this->application->fqdn = str($this->application->fqdn)->replaceEnd(',', '')->trim();
-            $this->application->fqdn = str($this->application->fqdn)->replaceStart(',', '')->trim();
-            $this->application->fqdn = str($this->application->fqdn)->trim()->explode(',')->map(function ($domain) {
+            $this->fqdn = str($this->fqdn)->replaceEnd(',', '')->trim()->toString();
+            $this->fqdn = str($this->fqdn)->replaceStart(',', '')->trim()->toString();
+            $domains = str($this->fqdn)->trim()->explode(',')->map(function ($domain) {
                 $domain = trim($domain);
                 Url::fromString($domain, ['http', 'https']);
 
                 return str($domain)->lower();
             });
-            $this->application->fqdn = $this->application->fqdn->unique()->implode(',');
-            $warning = sslipDomainWarning($this->application->fqdn);
+            $this->fqdn = $domains->unique()->implode(',');
+            $warning = sslipDomainWarning($this->fqdn);
             if ($warning) {
                 $this->dispatch('warning', __('warning.sslipdomain'));
             }
+            // Sync to model for domain conflict check
+            $this->syncToModel();
             // Check for domain conflicts if not forcing save
             if (! $this->forceSaveDomains) {
                 $result = checkDomainUsage(resource: $this->application);
@@ -175,6 +211,8 @@ class ServiceApplicationView extends Component
 
             $this->validate();
             $this->application->save();
+            $this->application->refresh();
+            $this->syncFromModel();
             updateCompose($this->application);
             if (str($this->application->fqdn)->contains(',')) {
                 $this->dispatch('warning', 'Some services do not support multiple domains, which can lead to problems and is NOT RECOMMENDED.<br><br>Only use multiple domains if you know what you are doing.');
@@ -186,6 +224,7 @@ class ServiceApplicationView extends Component
             $originalFqdn = $this->application->getOriginal('fqdn');
             if ($originalFqdn !== $this->application->fqdn) {
                 $this->application->fqdn = $originalFqdn;
+                $this->syncFromModel();
             }
 
             return handleError($e, $this);

app/Livewire/Project/Service/StackForm.php

@@ -15,14 +15,25 @@ class StackForm extends Component
 
     protected $listeners = ['saveCompose'];
 
+    // Explicit properties
+    public string $name;
+
+    public ?string $description = null;
+
+    public string $dockerComposeRaw;
+
+    public string $dockerCompose;
+
+    public ?bool $connectToDockerNetwork = null;
+
     protected function rules(): array
     {
         $baseRules = [
-            'service.docker_compose_raw' => 'required',
-            'service.docker_compose' => 'required',
-            'service.name' => ValidationPatterns::nameRules(),
-            'service.description' => ValidationPatterns::descriptionRules(),
-            'service.connect_to_docker_network' => 'nullable',
+            'dockerComposeRaw' => 'required',
+            'dockerCompose' => 'required',
+            'name' => ValidationPatterns::nameRules(),
+            'description' => ValidationPatterns::descriptionRules(),
+            'connectToDockerNetwork' => 'nullable',
         ];
 
         // Add dynamic field rules
@@ -39,19 +50,44 @@ class StackForm extends Component
         return array_merge(
             ValidationPatterns::combinedMessages(),
             [
-                'service.name.required' => 'The Name field is required.',
-                'service.name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
-                'service.description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
-                'service.docker_compose_raw.required' => 'The Docker Compose Raw field is required.',
-                'service.docker_compose.required' => 'The Docker Compose field is required.',
+                'name.required' => 'The Name field is required.',
+                'name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
+                'description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
+                'dockerComposeRaw.required' => 'The Docker Compose Raw field is required.',
+                'dockerCompose.required' => 'The Docker Compose field is required.',
             ]
         );
     }
 
     public $validationAttributes = [];
 
+    /**
+     * Sync data between component properties and model
+     *
+     * @param  bool  $toModel  If true, sync FROM properties TO model. If false, sync FROM model TO properties.
+     */
+    private function syncData(bool $toModel = false): void
+    {
+        if ($toModel) {
+            // Sync TO model (before save)
+            $this->service->name = $this->name;
+            $this->service->description = $this->description;
+            $this->service->docker_compose_raw = $this->dockerComposeRaw;
+            $this->service->docker_compose = $this->dockerCompose;
+            $this->service->connect_to_docker_network = $this->connectToDockerNetwork;
+        } else {
+            // Sync FROM model (on load/refresh)
+            $this->name = $this->service->name;
+            $this->description = $this->service->description;
+            $this->dockerComposeRaw = $this->service->docker_compose_raw;
+            $this->dockerCompose = $this->service->docker_compose;
+            $this->connectToDockerNetwork = $this->service->connect_to_docker_network;
+        }
+    }
+
     public function mount()
     {
+        $this->syncData(false);
         $this->fields = collect([]);
         $extraFields = $this->service->extraFields();
         foreach ($extraFields as $serviceName => $fields) {
@@ -87,12 +123,13 @@ class StackForm extends Component
 
     public function saveCompose($raw)
     {
-        $this->service->docker_compose_raw = $raw;
+        $this->dockerComposeRaw = $raw;
         $this->submit(notify: true);
     }
 
     public function instantSave()
     {
+        $this->syncData(true);
         $this->service->save();
         $this->dispatch('success', 'Service settings saved.');
     }
@@ -101,6 +138,11 @@ class StackForm extends Component
     {
         try {
             $this->validate();
+            $this->syncData(true);
+
+            // Validate for command injection BEFORE saving to database
+            validateDockerComposeForInjection($this->service->docker_compose_raw);
+
             $this->service->save();
             $this->service->saveExtraFields($this->fields);
             $this->service->parse();