Merge branch 'next' into template/metamcp

.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

.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

@@ -28,6 +28,13 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - 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: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
@@ -50,8 +57,8 @@ jobs:
           platforms: linux/amd64
           push: true
           tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}
 
   aarch64:
     runs-on: [self-hosted, arm64]
@@ -61,6 +68,13 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - 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: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
         with:
@@ -83,8 +97,8 @@ jobs:
           platforms: linux/aarch64
           push: true
           tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.ref_name }}-aarch64
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}-aarch64
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.sanitize.outputs.tag }}-aarch64
 
   merge-manifest:
     runs-on: ubuntu-latest
@@ -95,6 +109,13 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - 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
 
       - name: Login to ${{ env.GITHUB_REGISTRY }}
@@ -114,14 +135,14 @@ 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 }}
+         --append ${{ 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 }}
+          --append ${{ 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

@@ -160,6 +160,7 @@ ### Database Patterns
 - 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

README.md

@@ -53,40 +53,40 @@ # Donations
 
 ## 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 PR & AI Authority Building Agency
-* [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
+* [Darweb](https://darweb.nl/?ref=coolify.io) - Design. Develop. Deliver. Specialized in 3D CPQ Solutions
+* [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 @@ public function handle(StandaloneClickhouse $database)
         $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 @@ public function handle(StandaloneDragonfly $database)
             $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 @@ public function handle(StandaloneDragonfly $database)
         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 @@ public function handle(StandaloneKeydb $database)
             $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 @@ public function handle(StandaloneKeydb $database)
         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 @@ public function handle(StandaloneMariadb $database)
             $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 @@ public function handle(StandaloneMariadb $database)
         $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 @@ public function handle(StandaloneMongodb $database)
             $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 @@ public function handle(StandaloneMongodb $database)
         $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 @@ public function handle(StandaloneMysql $database)
             $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 @@ public function handle(StandaloneMysql $database)
         $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 @@ public function handle(StandalonePostgresql $database)
             $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 @@ public function handle(StandalonePostgresql $database)
         $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 @@ public function handle(StandaloneRedis $database)
             $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 @@ public function handle(StandaloneRedis $database)
         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 @@ private function stopContainer($database, string $containerName, int $timeout =
     {
         $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/StartProxy.php

@@ -19,6 +19,11 @@ public function handle(Server $server, bool $async = true, bool $force = false):
         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 @@ public function handle(Server $server, bool $async = true, bool $force = false):
             ]);
             $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 @@
 
 use App\Helpers\SslHelper;
 use App\Models\Server;
-use App\Models\SslCertificate;
 use App\Models\StandaloneDocker;
 use Lorisleiva\Actions\Concerns\AsAction;
 
@@ -20,7 +19,7 @@ public function handle(Server $server)
             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,

app/Actions/Stripe/CancelSubscription.php

@@ -30,7 +30,7 @@ public function getSubscriptionsPreview(): Collection
         $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 @@ public function getSubscriptionsPreview(): Collection
         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 @@ public function getResourcesPreview(): array
         $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 @@ public function execute(): array
 
         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 @@ public function getServersPreview(): Collection
         $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/CleanupStuckedResources.php

@@ -13,6 +13,7 @@
 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 @@ private function cleanup_stucked_resources()
         } 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 @@ private function cleanup_stucked_resources()
         } 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,744 +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\Cache;
-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;
-        }
-
-        // Implement file lock to prevent concurrent deletions of the same user
-        $lockKey = "user_deletion_{$this->user->id}";
-        $lock = Cache::lock($lockKey, 600); // 10 minute lock
-
-        if (! $lock->get()) {
-            $this->error('Another deletion process is already running for this user. Please try again later.');
-            $this->logAction("Deletion blocked for user {$email}: Another process is already running");
-
-            return 1;
-        }
-
-        try {
-            $this->logAction("Starting user deletion process for: {$email}");
-
-            // Phase 1: Show User Overview (outside transaction)
-            if (! $this->showUserOverview()) {
-                $this->info('User deletion cancelled.');
-                $lock->release();
-
-                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;
-        } finally {
-            // Ensure lock is always released
-            $lock->release();
-        }
-    }
-
-    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
-    {
-        // Try to get pricing from subscription metadata or config
-        // Since we're using dynamic pricing, return 0 for now
-        // This could be enhanced by fetching the actual price from Stripe API
-
-        // Check if this is a dynamic pricing plan
-        $dynamicMonthlyPlanId = config('subscription.stripe_price_id_dynamic_monthly');
-        $dynamicYearlyPlanId = config('subscription.stripe_price_id_dynamic_yearly');
-
-        if ($planId === $dynamicMonthlyPlanId || $planId === $dynamicYearlyPlanId) {
-            // For dynamic pricing, we can't determine the exact amount without calling Stripe API
-            // Return 0 to indicate dynamic/usage-based pricing
-            return 0;
-        }
-
-        // For any other plans, return 0 as we don't have hardcoded prices
-        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');
-
-        // Ensure the logs directory exists
-        $logDir = dirname($logFile);
-        if (! is_dir($logDir)) {
-            mkdir($logDir, 0755, true);
-        }
-
-        $timestamp = now()->format('Y-m-d H:i:s');
-        file_put_contents($logFile, "[{$timestamp}] {$logMessage}\n", FILE_APPEND | LOCK_EX);
-    }
-}

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\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,31 +1513,32 @@ private function create_application(Request $request, $type)
             if ($return instanceof \Illuminate\Http\JsonResponse) {
                 return $return;
             }
-            // Process docker image name and tag for SHA256 digests
+            // Process docker image name and tag using DockerImageParser
             $dockerImageName = $request->docker_registry_image_name;
             $dockerImageTag = $request->docker_registry_image_tag;
 
-            // Strip 'sha256:' prefix if user provided it in the tag
+            // Build the full Docker image string for parsing
             if ($dockerImageTag) {
-                $dockerImageTag = preg_replace('/^sha256:/i', '', trim($dockerImageTag));
+                $dockerImageString = $dockerImageName.':'.$dockerImageTag;
+            } else {
+                $dockerImageString = $dockerImageName;
             }
 
-            // Remove @sha256 from image name if user added it
-            if ($dockerImageName) {
-                $dockerImageName = preg_replace('/@sha256$/i', '', trim($dockerImageName));
-            }
+            // Parse using DockerImageParser to normalize the image reference
+            $parser = new DockerImageParser;
+            $parser->parse($dockerImageString);
 
-            // Check if tag is a valid SHA256 hash (64 hex characters)
-            $isSha256Hash = $dockerImageTag && preg_match('/^[a-f0-9]{64}$/i', $dockerImageTag);
+            // Get normalized image name and tag
+            $normalizedImageName = $parser->getFullImageNameWithoutTag();
 
-            // Append @sha256 to image name if using digest and not already present
-            if ($isSha256Hash && ! str_ends_with($dockerImageName, '@sha256')) {
-                $dockerImageName .= '@sha256';
+            // 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', $dockerImageName);
-            $request->offsetSet('docker_registry_image_tag', $dockerImageTag ?: 'latest');
+            $request->offsetSet('docker_registry_image_name', $normalizedImageName);
+            $request->offsetSet('docker_registry_image_tag', $parser->getTag());
 
             $application = new Application;
             removeUnnecessaryFieldsFromRequest($request);
@@ -2492,7 +2494,7 @@ public function envs(Request $request)
     )]
     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)) {
@@ -2520,6 +2522,8 @@ public function update_env_by_uuid(Request $request)
             'is_literal' => 'boolean',
             'is_multiline' => 'boolean',
             'is_shown_once' => 'boolean',
+            'is_runtime' => 'boolean',
+            'is_buildtime' => 'boolean',
         ]);
 
         $extraFields = array_diff(array_keys($request->all()), $allowedFields);
@@ -2715,7 +2719,7 @@ public function create_bulk_envs(Request $request)
             ], 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) {
@@ -2726,6 +2730,8 @@ public function create_bulk_envs(Request $request)
                 'is_literal' => 'boolean',
                 'is_multiline' => 'boolean',
                 'is_shown_once' => 'boolean',
+                'is_runtime' => 'boolean',
+                'is_buildtime' => 'boolean',
             ]);
             if ($validator->fails()) {
                 return response()->json([
@@ -2885,7 +2891,7 @@ public function create_bulk_envs(Request $request)
     )]
     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)) {
@@ -2908,6 +2914,8 @@ public function create_env(Request $request)
             'is_literal' => 'boolean',
             'is_multiline' => 'boolean',
             'is_shown_once' => 'boolean',
+            'is_runtime' => 'boolean',
+            'is_buildtime' => 'boolean',
         ]);
 
         $extraFields = array_diff(array_keys($request->all()), $allowedFields);

app/Http/Controllers/Api/DatabasesController.php

@@ -317,6 +317,10 @@ public function database_by_uuid(Request $request)
                 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 @@ public function update_by_uuid(Request $request)
         ]);
     }
 
+    #[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 @@ public function update_by_uuid(Request $request)
                 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 @@ public function update_backup(Request $request)
                 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 @@ public function create_database_postgresql(Request $request)
                 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 @@ public function create_database_clickhouse(Request $request)
                 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 @@ public function create_database_dragonfly(Request $request)
                 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 @@ public function create_database_redis(Request $request)
                 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 @@ public function create_database_keydb(Request $request)
                 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 @@ public function create_database_mariadb(Request $request)
                 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 @@ public function create_database_mysql(Request $request)
                 response: 400,
                 ref: '#/components/responses/400',
             ),
+            new OA\Response(
+                response: 422,
+                ref: '#/components/responses/422',
+            ),
         ]
     )]
     public function create_database_mongodb(Request $request)
@@ -1941,7 +2199,7 @@ public function delete_by_uuid(Request $request)
                 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 +2209,7 @@ public function delete_by_uuid(Request $request)
                 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.'),
                     ]
                 )
             ),
@@ -2065,7 +2323,7 @@ public function delete_backup_by_uuid(Request $request)
                 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 +2333,7 @@ public function delete_backup_by_uuid(Request $request)
                 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.'),
                     ]
                 )
             ),
@@ -2171,17 +2429,18 @@ public function delete_execution_by_uuid(Request $request)
                 content: new OA\JsonContent(
                     type: 'object',
                     properties: [
-                        'executions' => new OA\Schema(
+                        new OA\Property(
+                            property: 'executions',
                             type: 'array',
                             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 @@ public function deployment_by_uuid(Request $request)
         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 @@
 
 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,7 +301,8 @@ public function create_github_app(Request $request)
                     schema: new OA\Schema(
                         type: 'object',
                         properties: [
-                            'repositories' => new OA\Schema(
+                            new OA\Property(
+                                property: 'repositories',
                                 type: 'array',
                                 items: new OA\Items(type: 'object')
                             ),
@@ -335,7 +418,8 @@ public function load_repositories($github_app_id)
                     schema: new OA\Schema(
                         type: 'object',
                         properties: [
-                            'branches' => new OA\Schema(
+                            new OA\Property(
+                                property: 'branches',
                                 type: 'array',
                                 items: new OA\Items(type: 'object')
                             ),
@@ -457,7 +541,7 @@ public function load_branches($github_app_id, $owner, $repo)
             ),
             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 @@
                     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 @@ public function feedback(Request $request)
             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 @@ public function project_by_uuid(Request $request)
                 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 @@ public function environment_details(Request $request)
                 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 @@ public function create_project(Request $request)
                 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 @@ public function update_project(Request $request)
                 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 @@ public function delete_project(Request $request)
                 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 @@ public function get_environments(Request $request)
                 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 @@ public function create_environment(Request $request)
                 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 @@ public function key_by_uuid(Request $request)
                 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 @@ public function create_key(Request $request)
                 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 @@ public function domains_by_server(Request $request)
                 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 @@ public function create_server(Request $request)
                 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 @@ public function update_server(Request $request)
                 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 @@ public function delete_server(Request $request)
             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 @@ public function delete_server(Request $request)
                 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 @@ public function services(Request $request)
                 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 @@ public function create_service(Request $request)
                 });
             }
             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 @@ public function create_service(Request $request)
                     '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 @@ public function create_service(Request $request)
             $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;
 
@@ -704,6 +734,10 @@ public function delete_by_uuid(Request $request)
                 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 @@ public function update_by_uuid(Request $request)
             }
             $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 @@ public function envs(Request $request)
                 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 @@ public function update_env_by_uuid(Request $request)
                 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 @@ public function create_bulk_envs(Request $request)
                 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,7 +2,10 @@
 
 namespace App\Http\Middleware;
 
+use App\Models\InstanceSettings;
 use Illuminate\Http\Middleware\TrustHosts as Middleware;
+use Illuminate\Support\Facades\Cache;
+use Spatie\Url\Url;
 
 class TrustHosts extends Middleware
 {
@@ -13,8 +16,37 @@ 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 all subdomains of APP_URL as fallback
+        $trustedHosts[] = $this->allSubdomainsOfApplicationUrl();
+
+        return array_filter($trustedHosts);
     }
 }

app/Jobs/ApplicationDeploymentJob.php

@@ -484,9 +484,18 @@ private function deploy_simple_dockerfile()
         );
         $this->generate_image_names();
         $this->generate_compose_file();
+
+        // Save build-time .env file BEFORE the build
+        $this->save_buildtime_environment_variables();
+
         $this->generate_build_env_variables();
         $this->add_build_env_variables_to_dockerfile();
         $this->build_image();
+
+        // Save runtime environment variables AFTER the build
+        // This overwrites the build-time .env with ALL variables (build-time + runtime)
+        $this->save_runtime_environment_variables();
+
         $this->push_to_docker_registry();
         $this->rolling_update();
     }
@@ -1310,12 +1319,18 @@ private function save_runtime_environment_variables()
 
     private function generate_buildtime_environment_variables()
     {
+        if (isDev()) {
+            $this->application_deployment_queue->addLogEntry('[DEBUG] ========================================');
+            $this->application_deployment_queue->addLogEntry('[DEBUG] Generating build-time environment variables');
+            $this->application_deployment_queue->addLogEntry('[DEBUG] ========================================');
+        }
+
         $envs = collect([]);
         $coolify_envs = $this->generate_coolify_env_variables();
 
         // Add COOLIFY variables
         $coolify_envs->each(function ($item, $key) use ($envs) {
-            $envs->push($key.'='.$item);
+            $envs->push($key.'='.escapeBashEnvValue($item));
         });
 
         // Add SERVICE_NAME variables for Docker Compose builds
@@ -1329,7 +1344,7 @@ private function generate_buildtime_environment_variables()
                 }
                 $services = data_get($dockerCompose, 'services', []);
                 foreach ($services as $serviceName => $_) {
-                    $envs->push('SERVICE_NAME_'.str($serviceName)->upper().'='.$serviceName);
+                    $envs->push('SERVICE_NAME_'.str($serviceName)->upper().'='.escapeBashEnvValue($serviceName));
                 }
 
                 // Generate SERVICE_FQDN & SERVICE_URL for non-PR deployments
@@ -1342,8 +1357,8 @@ private function generate_buildtime_environment_variables()
                         $coolifyScheme = $coolifyUrl->getScheme();
                         $coolifyFqdn = $coolifyUrl->getHost();
                         $coolifyUrl = $coolifyUrl->withScheme($coolifyScheme)->withHost($coolifyFqdn)->withPort(null);
-                        $envs->push('SERVICE_URL_'.str($forServiceName)->upper().'='.$coolifyUrl->__toString());
-                        $envs->push('SERVICE_FQDN_'.str($forServiceName)->upper().'='.$coolifyFqdn);
+                        $envs->push('SERVICE_URL_'.str($forServiceName)->upper().'='.escapeBashEnvValue($coolifyUrl->__toString()));
+                        $envs->push('SERVICE_FQDN_'.str($forServiceName)->upper().'='.escapeBashEnvValue($coolifyFqdn));
                     }
                 }
             } else {
@@ -1351,7 +1366,7 @@ private function generate_buildtime_environment_variables()
                 $rawDockerCompose = Yaml::parse($this->application->docker_compose_raw);
                 $rawServices = data_get($rawDockerCompose, 'services', []);
                 foreach ($rawServices as $rawServiceName => $_) {
-                    $envs->push('SERVICE_NAME_'.str($rawServiceName)->upper().'='.addPreviewDeploymentSuffix($rawServiceName, $this->pull_request_id));
+                    $envs->push('SERVICE_NAME_'.str($rawServiceName)->upper().'='.escapeBashEnvValue(addPreviewDeploymentSuffix($rawServiceName, $this->pull_request_id)));
                 }
 
                 // Generate SERVICE_FQDN & SERVICE_URL for preview deployments with PR-specific domains
@@ -1364,8 +1379,8 @@ private function generate_buildtime_environment_variables()
                         $coolifyScheme = $coolifyUrl->getScheme();
                         $coolifyFqdn = $coolifyUrl->getHost();
                         $coolifyUrl = $coolifyUrl->withScheme($coolifyScheme)->withHost($coolifyFqdn)->withPort(null);
-                        $envs->push('SERVICE_URL_'.str($forServiceName)->upper().'='.$coolifyUrl->__toString());
-                        $envs->push('SERVICE_FQDN_'.str($forServiceName)->upper().'='.$coolifyFqdn);
+                        $envs->push('SERVICE_URL_'.str($forServiceName)->upper().'='.escapeBashEnvValue($coolifyUrl->__toString()));
+                        $envs->push('SERVICE_FQDN_'.str($forServiceName)->upper().'='.escapeBashEnvValue($coolifyFqdn));
                     }
                 }
             }
@@ -1387,7 +1402,32 @@ private function generate_buildtime_environment_variables()
             }
 
             foreach ($sorted_environment_variables as $env) {
-                $envs->push($env->key.'='.$env->real_value);
+                // For literal/multiline vars, real_value includes quotes that we need to remove
+                if ($env->is_literal || $env->is_multiline) {
+                    // Strip outer quotes from real_value and apply proper bash escaping
+                    $value = trim($env->real_value, "'");
+                    $escapedValue = escapeBashEnvValue($value);
+                    $envs->push($env->key.'='.$escapedValue);
+
+                    if (isDev()) {
+                        $this->application_deployment_queue->addLogEntry("[DEBUG] Build-time env: {$env->key}");
+                        $this->application_deployment_queue->addLogEntry('[DEBUG]   Type: literal/multiline');
+                        $this->application_deployment_queue->addLogEntry("[DEBUG]   raw real_value: {$env->real_value}");
+                        $this->application_deployment_queue->addLogEntry("[DEBUG]   stripped value: {$value}");
+                        $this->application_deployment_queue->addLogEntry("[DEBUG]   final escaped: {$escapedValue}");
+                    }
+                } else {
+                    // For normal vars, use double quotes to allow $VAR expansion
+                    $escapedValue = escapeBashDoubleQuoted($env->real_value);
+                    $envs->push($env->key.'='.$escapedValue);
+
+                    if (isDev()) {
+                        $this->application_deployment_queue->addLogEntry("[DEBUG] Build-time env: {$env->key}");
+                        $this->application_deployment_queue->addLogEntry('[DEBUG]   Type: normal (allows expansion)');
+                        $this->application_deployment_queue->addLogEntry("[DEBUG]   real_value: {$env->real_value}");
+                        $this->application_deployment_queue->addLogEntry("[DEBUG]   final escaped: {$escapedValue}");
+                    }
+                }
             }
         } else {
             $sorted_environment_variables = $this->application->environment_variables_preview()
@@ -1404,11 +1444,42 @@ private function generate_buildtime_environment_variables()
             }
 
             foreach ($sorted_environment_variables as $env) {
-                $envs->push($env->key.'='.$env->real_value);
+                // For literal/multiline vars, real_value includes quotes that we need to remove
+                if ($env->is_literal || $env->is_multiline) {
+                    // Strip outer quotes from real_value and apply proper bash escaping
+                    $value = trim($env->real_value, "'");
+                    $escapedValue = escapeBashEnvValue($value);
+                    $envs->push($env->key.'='.$escapedValue);
+
+                    if (isDev()) {
+                        $this->application_deployment_queue->addLogEntry("[DEBUG] Build-time env: {$env->key}");
+                        $this->application_deployment_queue->addLogEntry('[DEBUG]   Type: literal/multiline');
+                        $this->application_deployment_queue->addLogEntry("[DEBUG]   raw real_value: {$env->real_value}");
+                        $this->application_deployment_queue->addLogEntry("[DEBUG]   stripped value: {$value}");
+                        $this->application_deployment_queue->addLogEntry("[DEBUG]   final escaped: {$escapedValue}");
+                    }
+                } else {
+                    // For normal vars, use double quotes to allow $VAR expansion
+                    $escapedValue = escapeBashDoubleQuoted($env->real_value);
+                    $envs->push($env->key.'='.$escapedValue);
+
+                    if (isDev()) {
+                        $this->application_deployment_queue->addLogEntry("[DEBUG] Build-time env: {$env->key}");
+                        $this->application_deployment_queue->addLogEntry('[DEBUG]   Type: normal (allows expansion)');
+                        $this->application_deployment_queue->addLogEntry("[DEBUG]   real_value: {$env->real_value}");
+                        $this->application_deployment_queue->addLogEntry("[DEBUG]   final escaped: {$escapedValue}");
+                    }
+                }
             }
         }
 
         // Return the generated environment variables
+        if (isDev()) {
+            $this->application_deployment_queue->addLogEntry('[DEBUG] ========================================');
+            $this->application_deployment_queue->addLogEntry("[DEBUG] Total build-time env variables: {$envs->count()}");
+            $this->application_deployment_queue->addLogEntry('[DEBUG] ========================================');
+        }
+
         return $envs;
     }
 
@@ -1432,9 +1503,9 @@ private function save_buildtime_environment_variables()
                     'hidden' => true,
                 ],
             );
-        } elseif ($this->build_pack === 'dockercompose') {
-            // For Docker Compose, create an empty .env file even if there are no build-time variables
-            // This ensures the file exists when referenced in docker-compose commands
+        } elseif ($this->build_pack === 'dockercompose' || $this->build_pack === 'dockerfile') {
+            // For Docker Compose and Dockerfile, create an empty .env file even if there are no build-time variables
+            // This ensures the file exists when referenced in build commands
             $this->application_deployment_queue->addLogEntry('Creating empty build-time .env file in /artifacts (no build-time variables defined).', hidden: true);
 
             $this->execute_remote_command(
@@ -1888,9 +1959,27 @@ private function check_git_if_build_needed()
             );
         }
         if ($this->saved_outputs->get('git_commit_sha') && ! $this->rollback) {
-            $this->commit = $this->saved_outputs->get('git_commit_sha')->before("\t");
-            $this->application_deployment_queue->commit = $this->commit;
-            $this->application_deployment_queue->save();
+            // Extract commit SHA from git ls-remote output, handling multi-line output (e.g., redirect warnings)
+            // Expected format: "commit_sha\trefs/heads/branch" possibly preceded by warning lines
+            // Note: Git warnings can be on the same line as the result (no newline)
+            $lsRemoteOutput = $this->saved_outputs->get('git_commit_sha');
+
+            // Find the part containing a tab (the actual ls-remote result)
+            // Handle cases where warning is on the same line as the result
+            if ($lsRemoteOutput->contains("\t")) {
+                // Get everything from the last occurrence of a valid commit SHA pattern before the tab
+                // A valid commit SHA is 40 hex characters
+                $output = $lsRemoteOutput->value();
+
+                // Extract the line with the tab (actual ls-remote result)
+                preg_match('/\b([0-9a-fA-F]{40})(?=\s*\t)/', $output, $matches);
+
+                if (isset($matches[1])) {
+                    $this->commit = $matches[1];
+                    $this->application_deployment_queue->commit = $this->commit;
+                    $this->application_deployment_queue->save();
+                }
+            }
         }
         $this->set_coolify_variables();
 
@@ -1905,7 +1994,7 @@ private function clone_repository()
     {
         $importCommands = $this->generate_git_import_commands();
         $this->application_deployment_queue->addLogEntry("\n----------------------------------------");
-        $this->application_deployment_queue->addLogEntry("Importing {$this->customRepository}:{$this->application->git_branch} (commit sha {$this->application->git_commit_sha}) to {$this->basedir}.");
+        $this->application_deployment_queue->addLogEntry("Importing {$this->customRepository}:{$this->application->git_branch} (commit sha {$this->commit}) to {$this->basedir}.");
         if ($this->pull_request_id !== 0) {
             $this->application_deployment_queue->addLogEntry("Checking out tag pull/{$this->pull_request_id}/head.");
         }
@@ -2701,10 +2790,12 @@ private function build_image()
                     ]
                 );
             }
+            $publishDir = trim($this->application->publish_directory, '/');
+            $publishDir = $publishDir ? "/{$publishDir}" : '';
             $dockerfile = base64_encode("FROM {$this->application->static_image}
 WORKDIR /usr/share/nginx/html/
 LABEL coolify.deploymentId={$this->deployment_uuid}
-COPY --from=$this->build_image_name /app/{$this->application->publish_directory} .
+COPY --from=$this->build_image_name /app{$publishDir} .
 COPY ./nginx.conf /etc/nginx/conf.d/default.conf");
             if (str($this->application->custom_nginx_configuration)->isNotEmpty()) {
                 $nginx_config = base64_encode($this->application->custom_nginx_configuration);
@@ -3196,7 +3287,7 @@ private function add_build_env_variables_to_dockerfile()
             }
 
             $dockerfile_base64 = base64_encode($dockerfile->implode("\n"));
-            $this->application_deployment_queue->addLogEntry('Final Dockerfile:', type: 'info');
+            $this->application_deployment_queue->addLogEntry('Final Dockerfile:', type: 'info', hidden: true);
             $this->execute_remote_command(
                 [
                     executeInDocker($this->deployment_uuid, "echo '{$dockerfile_base64}' | base64 -d | tee {$this->workdir}{$this->dockerfile_location} > /dev/null"),

app/Jobs/ApplicationPullRequestUpdateJob.php

@@ -35,20 +35,24 @@ public function handle()
             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";
             }
+
+            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";

app/Jobs/DatabaseBackupJob.php

@@ -69,13 +69,12 @@ 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)
     {
         $this->onQueue('high');
         $this->timeout = $backup->timeout;
-        $this->backup_log_uuid = (string) new Cuid2;
     }
 
     public function handle(): void

app/Jobs/RegenerateSslCertJob.php

@@ -45,7 +45,7 @@ public function handle()
 
         $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/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 @@ public function handle()
                 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 @@ public function handle()
             ]);
 
         } 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 @@ public function handle()
         }
     }
 
+    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 @@ public function mount()
         $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::ownedByCurrentTeam(['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 @@ public function setServerType(string $type)
 
             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::ownedByCurrentTeam(['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 @@ public function getProxyType()
     public function selectExistingPrivateKey()
     {
         if (is_null($this->selectedExistingPrivateKey)) {
-            $this->restartBoarding();
+            $this->dispatch('error', 'Please select a private key.');
 
             return;
         }
@@ -202,6 +234,9 @@ public function setPrivateKey(string $type)
         $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/MonacoEditor.php

@@ -25,6 +25,7 @@ public function __construct(
         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/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 @@
 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 @@ protected function messages(): array
         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 @@ public function mount()
             $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
@@ -218,9 +294,6 @@ public function mount()
         }
         $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 @@ public function mount()
         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 @@ public function instantSave()
         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 @@ public function instantSave()
             $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) {
@@ -366,21 +500,21 @@ public function generateDomain(string $serviceName)
         }
     }
 
-    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 +522,28 @@ public function updatedApplicationBuildPack()
         } 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 +562,9 @@ public function updatedApplicationBuildPack()
                 $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 +580,11 @@ public function getWildcardDomain()
             $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 +598,11 @@ public function generateNginxConfiguration($type = 'static')
         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 +612,16 @@ public function generateNginxConfiguration($type = 'static')
     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 +632,8 @@ public function resetDefaultLabels($manualReset = false)
 
     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 +656,8 @@ public function checkFqdns($showToaster = true)
                 $this->forceSaveDomains = false;
             }
 
-            $this->application->fqdn = $domains->implode(',');
+            $this->fqdn = $domains->implode(',');
+            $this->application->fqdn = $this->fqdn;
             $this->resetDefaultLabels(false);
         }
 
@@ -547,21 +697,27 @@ public function submit($showToaster = true)
 
             $this->validate();
 
-            $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) {
+            $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();
@@ -581,38 +737,42 @@ public function submit($showToaster = true)
                 $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;
                 }
             }
 
-            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) {
@@ -643,12 +803,12 @@ public function submit($showToaster = true)
             }
             $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/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 @@ public function save_preview($preview_id)
             $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 @@ public function generate_preview($preview_id)
             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 @@ public function generate_preview($preview_id)
 
             $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 @@ public function add(int $pull_request_id, ?string $pull_request_html_url = null)
                 }
                 $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 @@ public function add(int $pull_request_id, ?string $pull_request_html_url = null)
                 }
                 $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 @@ public function save()
         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 @@ public function generate()
         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,24 +75,40 @@ public function generate()
                 $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();
-                $portInt = $url->getPort();
-                $port = $portInt !== null ? ':'.$portInt : '';
                 $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 = str_replace('{{port}}', $port, $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/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) {

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 @@ public function getListeners()
     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 @@ public function mount()
                 ->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\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 @@ public function getListeners()
     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 @@ public function regenerateSslCertificate()
 
             $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/Import.php

@@ -131,6 +131,7 @@ public function getContainers()
         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\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 @@ public function getListeners()
         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 @@ public function regenerateSslCertificate()
                 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\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 @@ public function getListeners()
 
         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 @@ protected function messages(): array
         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 @@ public function instantSaveAdvanced()
             $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 @@ public function submit()
         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 @@ public function instantSave()
         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 @@ public function instantSave()
                 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 @@ public function instantSaveSSL()
         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 @@ public function regenerateSslCertificate()
                 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 @@ public function regenerateSslCertificate()
     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\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 @@ public function getListeners()
 
         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 @@ protected function messages(): array
         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 @@ public function instantSaveAdvanced()
             $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 @@ public function submit()
         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 @@ public function instantSave()
         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 @@ public function instantSave()
                 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 @@ public function instantSaveSSL()
         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 @@ public function regenerateSslCertificate()
                 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 @@ public function regenerateSslCertificate()
     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\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 @@ public function getListeners()
 
         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 @@ protected function messages(): array
         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 @@ public function instantSaveAdvanced()
             $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 @@ public function submit()
         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 @@ public function instantSave()
         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 @@ public function instantSave()
                 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 @@ public function instantSaveSSL()
         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 @@ public function regenerateSslCertificate()
                 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 @@ public function regenerateSslCertificate()
     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\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 @@ public function getListeners()
 
         return [
             "echo-private:user.{$userId},DatabaseStatusChanged" => '$refresh',
-            'refresh' => '$refresh',
             'save_init_script',
             'delete_init_script',
         ];
@@ -48,23 +80,23 @@ public function getListeners()
     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 @@ protected function messages(): array
         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 @@ public function instantSaveAdvanced()
             $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 @@ public function instantSaveAdvanced()
         }
     }
 
-    public function updatedDatabaseSslMode()
+    public function updatedSslMode()
     {
         $this->instantSaveSSL();
     }
@@ -147,10 +236,8 @@ public function instantSaveSSL()
         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 @@ public function regenerateSslCertificate()
                 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 @@ public function instantSave()
         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 @@ public function instantSave()
                 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 @@ public function save_init_script($script)
     {
         $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 @@ public function save_init_script($script)
             $initScripts->push($script);
         }
 
-        $this->database->init_scripts = $initScripts->values()
+        $this->initScripts = $initScripts->values()
             ->map(function ($item, $index) {
                 $item['index'] = $index;
 
@@ -271,7 +357,7 @@ public function save_init_script($script)
             })
             ->all();
 
-        $this->database->save();
+        $this->syncData(true);
         $this->dispatch('success', 'Init script saved and updated.');
     }
 
@@ -279,7 +365,7 @@ public function delete_init_script($script)
     {
         $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 @@ public function delete_init_script($script)
                 })
                 ->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 @@ public function save_new_init_script()
             '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 @@ public function submit()
         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\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 @@ public function getListeners()
         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 @@ protected function messages(): array
         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 @@ public function instantSaveAdvanced()
             $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 @@ public function submit()
         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 @@ public function instantSave()
         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 @@ public function instantSave()
                 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 @@ public function instantSaveSSL()
         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 @@ public function regenerateSslCertificate()
                 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 @@ public function regenerateSslCertificate()
     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/New/DockerCompose.php

@@ -37,6 +37,10 @@ public function submit()
                 '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

@@ -28,18 +28,60 @@ public function mount()
         $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()
     {
-        // Strip 'sha256:' prefix if user pasted it
-        if ($this->imageSha256) {
-            $this->imageSha256 = preg_replace('/^sha256:/i', '', trim($this->imageSha256));
-        }
-
-        // Remove @sha256 from image name if user added it
-        if ($this->imageName) {
-            $this->imageName = preg_replace('/@sha256$/i', '', trim($this->imageName));
-        }
-
         $this->validate([
             'imageName' => ['required', 'string'],
             'imageTag' => ['nullable', 'string', 'regex:/^[a-z0-9][a-z0-9._-]*$/i'],
@@ -56,13 +98,16 @@ public function submit()
 
         // Build the full Docker image string
         if ($this->imageSha256) {
-            $dockerImage = $this->imageName.'@sha256:'.$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($dockerImage);
 
@@ -79,15 +124,15 @@ public function submit()
         $project = Project::where('uuid', $this->parameters['project_uuid'])->first();
         $environment = $project->load(['environments'])->environments->where('uuid', $this->parameters['environment_uuid'])->first();
 
-        // Determine the image tag based on whether it's a hash or regular tag
-        $imageTag = $parser->isImageHash() ? 'sha256-'.$parser->getTag() : $parser->getTag();
-
         // 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,
@@ -96,7 +141,7 @@ public function submit()
             'build_pack' => 'dockerimage',
             'ports_exposes' => 80,
             'docker_registry_image_name' => $imageName,
-            'docker_registry_image_tag' => $parser->getTag(),
+            'docker_registry_image_tag' => $imageTag,
             'environment_id' => $environment->id,
             'destination_id' => $destination->id,
             'destination_type' => $destination_class,

app/Livewire/Project/Resource/Create.php

@@ -81,7 +81,7 @@ public function mount()
                         '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 @@ public function getListeners()
 
         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 @@ public function mount()
                 $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 @@ public function instantSaveLogDrain()
         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 @@ public function instantSave()
     {
         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 @@ public function submit()
         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 @@ public function validateCompose()
     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 @@ public function confirmDomainUsage()
     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 @@ public function submit()
 
             $this->validate();
             $this->application->save();
+            $this->application->refresh();
+            $this->syncData(false);
             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->syncData(false);
             }
 
             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 @@
 
 class FileStorage extends Component
 {
-    use AuthorizesRequests;
+    use AuthorizesRequests, SynchronizesModelData;
 
     public LocalFileVolume $fileStorage;
 
@@ -36,12 +37,16 @@ class FileStorage extends Component
 
     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()
@@ -56,6 +61,15 @@ public function mount()
         }
 
         $this->isReadOnly = $this->fileStorage->isReadOnlyVolume();
+        $this->syncFromModel();
+    }
+
+    protected function getModelBindings(): array
+    {
+        return [
+            'content' => 'fileStorage.content',
+            'isBasedOnGit' => 'fileStorage.is_based_on_git',
+        ];
     }
 
     public function convertToDirectory()
@@ -82,6 +96,7 @@ public function loadStorageOnServer()
             $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);
@@ -148,14 +163,16 @@ public function submit()
         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/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 @@
 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 @@ public function instantSaveAdvanced()
         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 @@ public function mount()
         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 @@ public function submit()
     {
         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 @@ public function submit()
 
             $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 @@ public function submit()
             $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 @@ protected function messages(): array
         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 @@ public function mount()
 
     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 @@ public function submit($notify = true)
     {
         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();

app/Livewire/Project/Shared/HealthChecks.php

@@ -2,35 +2,90 @@
 
 namespace App\Livewire\Project\Shared;
 
+use App\Livewire\Concerns\SynchronizesModelData;
 use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
 use Livewire\Component;
 
 class HealthChecks extends Component
 {
     use AuthorizesRequests;
+    use SynchronizesModelData;
 
     public $resource;
 
-    protected $rules = [
-        'resource.health_check_enabled' => 'boolean',
-        'resource.health_check_path' => 'string',
-        'resource.health_check_port' => 'nullable|string',
-        'resource.health_check_host' => 'string',
-        'resource.health_check_method' => 'string',
-        'resource.health_check_return_code' => 'integer',
-        'resource.health_check_scheme' => 'string',
-        'resource.health_check_response_text' => 'nullable|string',
-        'resource.health_check_interval' => 'integer|min:1',
-        'resource.health_check_timeout' => 'integer|min:1',
-        'resource.health_check_retries' => 'integer|min:1',
-        'resource.health_check_start_period' => 'integer',
-        'resource.custom_healthcheck_found' => 'boolean',
+    // Explicit properties
+    public bool $healthCheckEnabled = false;
 
+    public string $healthCheckMethod;
+
+    public string $healthCheckScheme;
+
+    public string $healthCheckHost;
+
+    public ?string $healthCheckPort = null;
+
+    public string $healthCheckPath;
+
+    public int $healthCheckReturnCode;
+
+    public ?string $healthCheckResponseText = null;
+
+    public int $healthCheckInterval;
+
+    public int $healthCheckTimeout;
+
+    public int $healthCheckRetries;
+
+    public int $healthCheckStartPeriod;
+
+    public bool $customHealthcheckFound = false;
+
+    protected $rules = [
+        'healthCheckEnabled' => 'boolean',
+        'healthCheckPath' => 'string',
+        'healthCheckPort' => 'nullable|string',
+        'healthCheckHost' => 'string',
+        'healthCheckMethod' => 'string',
+        'healthCheckReturnCode' => 'integer',
+        'healthCheckScheme' => 'string',
+        'healthCheckResponseText' => 'nullable|string',
+        'healthCheckInterval' => 'integer|min:1',
+        'healthCheckTimeout' => 'integer|min:1',
+        'healthCheckRetries' => 'integer|min:1',
+        'healthCheckStartPeriod' => 'integer',
+        'customHealthcheckFound' => 'boolean',
     ];
 
+    protected function getModelBindings(): array
+    {
+        return [
+            'healthCheckEnabled' => 'resource.health_check_enabled',
+            'healthCheckMethod' => 'resource.health_check_method',
+            'healthCheckScheme' => 'resource.health_check_scheme',
+            'healthCheckHost' => 'resource.health_check_host',
+            'healthCheckPort' => 'resource.health_check_port',
+            'healthCheckPath' => 'resource.health_check_path',
+            'healthCheckReturnCode' => 'resource.health_check_return_code',
+            'healthCheckResponseText' => 'resource.health_check_response_text',
+            'healthCheckInterval' => 'resource.health_check_interval',
+            'healthCheckTimeout' => 'resource.health_check_timeout',
+            'healthCheckRetries' => 'resource.health_check_retries',
+            'healthCheckStartPeriod' => 'resource.health_check_start_period',
+            'customHealthcheckFound' => 'resource.custom_healthcheck_found',
+        ];
+    }
+
+    public function mount()
+    {
+        $this->authorize('view', $this->resource);
+        $this->syncFromModel();
+    }
+
     public function instantSave()
     {
         $this->authorize('update', $this->resource);
+
+        $this->syncToModel();
         $this->resource->save();
         $this->dispatch('success', 'Health check updated.');
     }
@@ -40,6 +95,8 @@ public function submit()
         try {
             $this->authorize('update', $this->resource);
             $this->validate();
+
+            $this->syncToModel();
             $this->resource->save();
             $this->dispatch('success', 'Health check updated.');
         } catch (\Throwable $e) {
@@ -51,14 +108,16 @@ public function toggleHealthcheck()
     {
         try {
             $this->authorize('update', $this->resource);
-            $wasEnabled = $this->resource->health_check_enabled;
-            $this->resource->health_check_enabled = ! $this->resource->health_check_enabled;
+            $wasEnabled = $this->healthCheckEnabled;
+            $this->healthCheckEnabled = ! $this->healthCheckEnabled;
+
+            $this->syncToModel();
             $this->resource->save();
 
-            if ($this->resource->health_check_enabled && ! $wasEnabled && $this->resource->isRunning()) {
+            if ($this->healthCheckEnabled && ! $wasEnabled && $this->resource->isRunning()) {
                 $this->dispatch('info', 'Health check has been enabled. A restart is required to apply the new settings.');
             } else {
-                $this->dispatch('success', 'Health check '.($this->resource->health_check_enabled ? 'enabled' : 'disabled').'.');
+                $this->dispatch('success', 'Health check '.($this->healthCheckEnabled ? 'enabled' : 'disabled').'.');
             }
         } catch (\Throwable $e) {
             return handleError($e, $this);

app/Livewire/Project/Shared/ResourceLimits.php

@@ -11,52 +11,105 @@ class ResourceLimits extends Component
 
     public $resource;
 
+    // Explicit properties
+    public ?string $limitsCpus = null;
+
+    public ?string $limitsCpuset = null;
+
+    public ?int $limitsCpuShares = null;
+
+    public string $limitsMemory;
+
+    public string $limitsMemorySwap;
+
+    public int $limitsMemorySwappiness;
+
+    public string $limitsMemoryReservation;
+
     protected $rules = [
-        'resource.limits_memory' => 'required|string',
-        'resource.limits_memory_swap' => 'required|string',
-        'resource.limits_memory_swappiness' => 'required|integer|min:0|max:100',
-        'resource.limits_memory_reservation' => 'required|string',
-        'resource.limits_cpus' => 'nullable',
-        'resource.limits_cpuset' => 'nullable',
-        'resource.limits_cpu_shares' => 'nullable',
+        'limitsMemory' => 'required|string',
+        'limitsMemorySwap' => 'required|string',
+        'limitsMemorySwappiness' => 'required|integer|min:0|max:100',
+        'limitsMemoryReservation' => 'required|string',
+        'limitsCpus' => 'nullable',
+        'limitsCpuset' => 'nullable',
+        'limitsCpuShares' => 'nullable',
     ];
 
     protected $validationAttributes = [
-        'resource.limits_memory' => 'memory',
-        'resource.limits_memory_swap' => 'swap',
-        'resource.limits_memory_swappiness' => 'swappiness',
-        'resource.limits_memory_reservation' => 'reservation',
-        'resource.limits_cpus' => 'cpus',
-        'resource.limits_cpuset' => 'cpuset',
-        'resource.limits_cpu_shares' => 'cpu shares',
+        'limitsMemory' => 'memory',
+        'limitsMemorySwap' => 'swap',
+        'limitsMemorySwappiness' => 'swappiness',
+        'limitsMemoryReservation' => 'reservation',
+        'limitsCpus' => 'cpus',
+        'limitsCpuset' => 'cpuset',
+        'limitsCpuShares' => 'cpu shares',
     ];
 
+    /**
+     * 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->resource->limits_cpus = $this->limitsCpus;
+            $this->resource->limits_cpuset = $this->limitsCpuset;
+            $this->resource->limits_cpu_shares = $this->limitsCpuShares;
+            $this->resource->limits_memory = $this->limitsMemory;
+            $this->resource->limits_memory_swap = $this->limitsMemorySwap;
+            $this->resource->limits_memory_swappiness = $this->limitsMemorySwappiness;
+            $this->resource->limits_memory_reservation = $this->limitsMemoryReservation;
+        } else {
+            // Sync FROM model (on load/refresh)
+            $this->limitsCpus = $this->resource->limits_cpus;
+            $this->limitsCpuset = $this->resource->limits_cpuset;
+            $this->limitsCpuShares = $this->resource->limits_cpu_shares;
+            $this->limitsMemory = $this->resource->limits_memory;
+            $this->limitsMemorySwap = $this->resource->limits_memory_swap;
+            $this->limitsMemorySwappiness = $this->resource->limits_memory_swappiness;
+            $this->limitsMemoryReservation = $this->resource->limits_memory_reservation;
+        }
+    }
+
+    public function mount()
+    {
+        $this->syncData(false);
+    }
+
     public function submit()
     {
         try {
             $this->authorize('update', $this->resource);
-            if (! $this->resource->limits_memory) {
-                $this->resource->limits_memory = '0';
+
+            // Apply default values to properties
+            if (! $this->limitsMemory) {
+                $this->limitsMemory = '0';
             }
-            if (! $this->resource->limits_memory_swap) {
-                $this->resource->limits_memory_swap = '0';
+            if (! $this->limitsMemorySwap) {
+                $this->limitsMemorySwap = '0';
             }
-            if (is_null($this->resource->limits_memory_swappiness)) {
-                $this->resource->limits_memory_swappiness = '60';
+            if (is_null($this->limitsMemorySwappiness)) {
+                $this->limitsMemorySwappiness = 60;
             }
-            if (! $this->resource->limits_memory_reservation) {
-                $this->resource->limits_memory_reservation = '0';
+            if (! $this->limitsMemoryReservation) {
+                $this->limitsMemoryReservation = '0';
             }
-            if (! $this->resource->limits_cpus) {
-                $this->resource->limits_cpus = '0';
+            if (! $this->limitsCpus) {
+                $this->limitsCpus = '0';
             }
-            if ($this->resource->limits_cpuset === '') {
-                $this->resource->limits_cpuset = null;
+            if ($this->limitsCpuset === '') {
+                $this->limitsCpuset = null;
             }
-            if (is_null($this->resource->limits_cpu_shares)) {
-                $this->resource->limits_cpu_shares = 1024;
+            if (is_null($this->limitsCpuShares)) {
+                $this->limitsCpuShares = 1024;
             }
+
             $this->validate();
+
+            $this->syncData(true);
             $this->resource->save();
             $this->dispatch('success', 'Resource limits updated.');
         } catch (\Throwable $e) {

app/Livewire/Project/Shared/Storages/Show.php

@@ -25,20 +25,48 @@ class Show extends Component
 
     public ?string $startedAt = null;
 
+    // Explicit properties
+    public string $name;
+
+    public string $mountPath;
+
+    public ?string $hostPath = null;
+
     protected $rules = [
-        'storage.name' => 'required|string',
-        'storage.mount_path' => 'required|string',
-        'storage.host_path' => 'string|nullable',
+        'name' => 'required|string',
+        'mountPath' => 'required|string',
+        'hostPath' => 'string|nullable',
     ];
 
     protected $validationAttributes = [
         'name' => 'name',
-        'mount_path' => 'mount',
-        'host_path' => 'host',
+        'mountPath' => 'mount',
+        'hostPath' => 'host',
     ];
 
+    /**
+     * 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->storage->name = $this->name;
+            $this->storage->mount_path = $this->mountPath;
+            $this->storage->host_path = $this->hostPath;
+        } else {
+            // Sync FROM model (on load/refresh)
+            $this->name = $this->storage->name;
+            $this->mountPath = $this->storage->mount_path;
+            $this->hostPath = $this->storage->host_path;
+        }
+    }
+
     public function mount()
     {
+        $this->syncData(false);
         $this->isReadOnly = $this->storage->isReadOnlyVolume();
     }
 
@@ -47,6 +75,7 @@ public function submit()
         $this->authorize('update', $this->resource);
 
         $this->validate();
+        $this->syncData(true);
         $this->storage->save();
         $this->dispatch('success', 'Storage updated successfully');
     }

app/Livewire/Security/CloudInitScriptForm.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace App\Livewire\Security;
+
+use App\Models\CloudInitScript;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Livewire\Component;
+
+class CloudInitScriptForm extends Component
+{
+    use AuthorizesRequests;
+
+    public bool $modal_mode = true;
+
+    public ?int $scriptId = null;
+
+    public string $name = '';
+
+    public string $script = '';
+
+    public function mount(?int $scriptId = null)
+    {
+        if ($scriptId) {
+            $this->scriptId = $scriptId;
+            $cloudInitScript = CloudInitScript::ownedByCurrentTeam()->findOrFail($scriptId);
+            $this->authorize('update', $cloudInitScript);
+
+            $this->name = $cloudInitScript->name;
+            $this->script = $cloudInitScript->script;
+        } else {
+            $this->authorize('create', CloudInitScript::class);
+        }
+    }
+
+    protected function rules(): array
+    {
+        return [
+            'name' => 'required|string|max:255',
+            'script' => ['required', 'string', new \App\Rules\ValidCloudInitYaml],
+        ];
+    }
+
+    protected function messages(): array
+    {
+        return [
+            'name.required' => 'Script name is required.',
+            'name.max' => 'Script name cannot exceed 255 characters.',
+            'script.required' => 'Cloud-init script content is required.',
+        ];
+    }
+
+    public function save()
+    {
+        $this->validate();
+
+        try {
+            if ($this->scriptId) {
+                // Update existing script
+                $cloudInitScript = CloudInitScript::ownedByCurrentTeam()->findOrFail($this->scriptId);
+                $this->authorize('update', $cloudInitScript);
+
+                $cloudInitScript->update([
+                    'name' => $this->name,
+                    'script' => $this->script,
+                ]);
+
+                $message = 'Cloud-init script updated successfully.';
+            } else {
+                // Create new script
+                $this->authorize('create', CloudInitScript::class);
+
+                CloudInitScript::create([
+                    'team_id' => currentTeam()->id,
+                    'name' => $this->name,
+                    'script' => $this->script,
+                ]);
+
+                $message = 'Cloud-init script created successfully.';
+            }
+
+            // Only reset fields if creating (not editing)
+            if (! $this->scriptId) {
+                $this->reset(['name', 'script']);
+            }
+
+            $this->dispatch('scriptSaved');
+            $this->dispatch('success', $message);
+
+            if ($this->modal_mode) {
+                $this->dispatch('closeModal');
+            }
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function render()
+    {
+        return view('livewire.security.cloud-init-script-form');
+    }
+}

app/Livewire/Security/CloudInitScripts.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Livewire\Security;
+
+use App\Models\CloudInitScript;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Livewire\Component;
+
+class CloudInitScripts extends Component
+{
+    use AuthorizesRequests;
+
+    public $scripts;
+
+    public function mount()
+    {
+        $this->authorize('viewAny', CloudInitScript::class);
+        $this->loadScripts();
+    }
+
+    public function getListeners()
+    {
+        return [
+            'scriptSaved' => 'loadScripts',
+        ];
+    }
+
+    public function loadScripts()
+    {
+        $this->scripts = CloudInitScript::ownedByCurrentTeam()->orderBy('created_at', 'desc')->get();
+    }
+
+    public function deleteScript(int $scriptId)
+    {
+        try {
+            $script = CloudInitScript::ownedByCurrentTeam()->findOrFail($scriptId);
+            $this->authorize('delete', $script);
+
+            $script->delete();
+            $this->loadScripts();
+
+            $this->dispatch('success', 'Cloud-init script deleted successfully.');
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function render()
+    {
+        return view('livewire.security.cloud-init-scripts');
+    }
+}

app/Livewire/Security/CloudProviderTokenForm.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace App\Livewire\Security;
+
+use App\Models\CloudProviderToken;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Illuminate\Support\Facades\Http;
+use Livewire\Component;
+
+class CloudProviderTokenForm extends Component
+{
+    use AuthorizesRequests;
+
+    public bool $modal_mode = false;
+
+    public string $provider = 'hetzner';
+
+    public string $token = '';
+
+    public string $name = '';
+
+    public function mount()
+    {
+        $this->authorize('create', CloudProviderToken::class);
+    }
+
+    protected function rules(): array
+    {
+        return [
+            'provider' => 'required|string|in:hetzner,digitalocean',
+            'token' => 'required|string',
+            'name' => 'required|string|max:255',
+        ];
+    }
+
+    protected function messages(): array
+    {
+        return [
+            'provider.required' => 'Please select a cloud provider.',
+            'provider.in' => 'Invalid cloud provider selected.',
+            'token.required' => 'API token is required.',
+            'name.required' => 'Token name is required.',
+        ];
+    }
+
+    private function validateToken(string $provider, string $token): bool
+    {
+        try {
+            if ($provider === 'hetzner') {
+                $response = Http::withHeaders([
+                    'Authorization' => 'Bearer '.$token,
+                ])->timeout(10)->get('https://api.hetzner.cloud/v1/servers');
+                ray($response);
+
+                return $response->successful();
+            }
+
+            // Add other providers here in the future
+            // if ($provider === 'digitalocean') { ... }
+
+            return false;
+        } catch (\Throwable $e) {
+            return false;
+        }
+    }
+
+    public function addToken()
+    {
+        $this->validate();
+
+        try {
+            // Validate the token with the provider's API
+            if (! $this->validateToken($this->provider, $this->token)) {
+                return $this->dispatch('error', 'Invalid API token. Please check your token and try again.');
+            }
+
+            $savedToken = CloudProviderToken::create([
+                'team_id' => currentTeam()->id,
+                'provider' => $this->provider,
+                'token' => $this->token,
+                'name' => $this->name,
+            ]);
+
+            $this->reset(['token', 'name']);
+
+            // Dispatch event with token ID so parent components can react
+            $this->dispatch('tokenAdded', tokenId: $savedToken->id);
+
+            $this->dispatch('success', 'Cloud provider token added successfully.');
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function render()
+    {
+        return view('livewire.security.cloud-provider-token-form');
+    }
+}

app/Livewire/Security/CloudProviderTokens.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Livewire\Security;
+
+use App\Models\CloudProviderToken;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Livewire\Component;
+
+class CloudProviderTokens extends Component
+{
+    use AuthorizesRequests;
+
+    public $tokens;
+
+    public function mount()
+    {
+        $this->authorize('viewAny', CloudProviderToken::class);
+        $this->loadTokens();
+    }
+
+    public function getListeners()
+    {
+        return [
+            'tokenAdded' => 'loadTokens',
+        ];
+    }
+
+    public function loadTokens()
+    {
+        $this->tokens = CloudProviderToken::ownedByCurrentTeam()->get();
+    }
+
+    public function deleteToken(int $tokenId)
+    {
+        try {
+            $token = CloudProviderToken::ownedByCurrentTeam()->findOrFail($tokenId);
+            $this->authorize('delete', $token);
+
+            // Check if any servers are using this token
+            if ($token->hasServers()) {
+                $serverCount = $token->servers()->count();
+                $this->dispatch('error', "Cannot delete this token. It is currently used by {$serverCount} server(s). Please reassign those servers to a different token first.");
+
+                return;
+            }
+
+            $token->delete();
+            $this->loadTokens();
+
+            $this->dispatch('success', 'Cloud provider token deleted successfully.');
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function render()
+    {
+        return view('livewire.security.cloud-provider-tokens');
+    }
+}

app/Livewire/Security/CloudTokens.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Livewire\Security;
+
+use Livewire\Component;
+
+class CloudTokens extends Component
+{
+    public function render()
+    {
+        return view('livewire.security.cloud-tokens');
+    }
+}

app/Livewire/Security/PrivateKey/Create.php

@@ -21,6 +21,8 @@ class Create extends Component
 
     public ?string $publicKey = null;
 
+    public bool $modal_mode = false;
+
     protected function rules(): array
     {
         return [
@@ -77,6 +79,14 @@ public function createPrivateKey()
                 'team_id' => currentTeam()->id,
             ]);
 
+            // If in modal mode, dispatch event and don't redirect
+            if ($this->modal_mode) {
+                $this->dispatch('privateKeyCreated', keyId: $privateKey->id);
+                $this->dispatch('success', 'Private key created successfully.');
+
+                return;
+            }
+
             return $this->redirectAfterCreation($privateKey);
         } catch (\Throwable $e) {
             return handleError($e, $this);

app/Livewire/Security/PrivateKey/Index.php

@@ -12,7 +12,7 @@ class Index extends Component
 
     public function render()
     {
-        $privateKeys = PrivateKey::ownedByCurrentTeam(['name', 'uuid', 'is_git_related', 'description'])->get();
+        $privateKeys = PrivateKey::ownedByCurrentTeam(['name', 'uuid', 'is_git_related', 'description', 'team_id'])->get();
 
         return view('livewire.security.private-key.index', [
             'privateKeys' => $privateKeys,

app/Livewire/Security/PrivateKey/Show.php

@@ -13,15 +13,24 @@ class Show extends Component
 
     public PrivateKey $private_key;
 
+    // Explicit properties
+    public string $name;
+
+    public ?string $description = null;
+
+    public string $privateKeyValue;
+
+    public bool $isGitRelated = false;
+
     public $public_key = 'Loading...';
 
     protected function rules(): array
     {
         return [
-            'private_key.name' => ValidationPatterns::nameRules(),
-            'private_key.description' => ValidationPatterns::descriptionRules(),
-            'private_key.private_key' => 'required|string',
-            'private_key.is_git_related' => 'nullable|boolean',
+            'name' => ValidationPatterns::nameRules(),
+            'description' => ValidationPatterns::descriptionRules(),
+            'privateKeyValue' => 'required|string',
+            'isGitRelated' => 'nullable|boolean',
         ];
     }
 
@@ -30,25 +39,54 @@ protected function messages(): array
         return array_merge(
             ValidationPatterns::combinedMessages(),
             [
-                'private_key.name.required' => 'The Name field is required.',
-                'private_key.name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
-                'private_key.description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
-                'private_key.private_key.required' => 'The Private Key field is required.',
-                'private_key.private_key.string' => 'The Private Key must be a valid 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.',
+                'privateKeyValue.required' => 'The Private Key field is required.',
+                'privateKeyValue.string' => 'The Private Key must be a valid string.',
             ]
         );
     }
 
     protected $validationAttributes = [
-        'private_key.name' => 'name',
-        'private_key.description' => 'description',
-        'private_key.private_key' => 'private key',
+        'name' => 'name',
+        'description' => 'description',
+        'privateKeyValue' => 'private key',
     ];
 
+    /**
+     * 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->private_key->name = $this->name;
+            $this->private_key->description = $this->description;
+            $this->private_key->private_key = $this->privateKeyValue;
+            $this->private_key->is_git_related = $this->isGitRelated;
+        } else {
+            // Sync FROM model (on load/refresh)
+            $this->name = $this->private_key->name;
+            $this->description = $this->private_key->description;
+            $this->privateKeyValue = $this->private_key->private_key;
+            $this->isGitRelated = $this->private_key->is_git_related;
+        }
+    }
+
     public function mount()
     {
         try {
-            $this->private_key = PrivateKey::ownedByCurrentTeam(['name', 'description', 'private_key', 'is_git_related'])->whereUuid(request()->private_key_uuid)->firstOrFail();
+            $this->private_key = PrivateKey::ownedByCurrentTeam(['name', 'description', 'private_key', 'is_git_related', 'team_id'])->whereUuid(request()->private_key_uuid)->firstOrFail();
+
+            // Explicit authorization check - will throw 403 if not authorized
+            $this->authorize('view', $this->private_key);
+
+            $this->syncData(false);
+        } catch (\Illuminate\Auth\Access\AuthorizationException $e) {
+            abort(403, 'You do not have permission to view this private key.');
         } catch (\Throwable) {
             abort(404);
         }
@@ -81,6 +119,10 @@ public function changePrivateKey()
     {
         try {
             $this->authorize('update', $this->private_key);
+
+            $this->validate();
+
+            $this->syncData(true);
             $this->private_key->updatePrivateKey([
                 'private_key' => formatPrivateKey($this->private_key->private_key),
             ]);

app/Livewire/Server/CaCertificate/Show.php

@@ -39,7 +39,7 @@ public function mount(string $server_uuid)
 
     public function loadCaCertificate()
     {
-        $this->caCertificate = SslCertificate::where('server_id', $this->server->id)->where('is_ca_certificate', true)->first();
+        $this->caCertificate = $this->server->sslCertificates()->where('is_ca_certificate', true)->first();
 
         if ($this->caCertificate) {
             $this->certificateContent = $this->caCertificate->ssl_certificate;

app/Livewire/Server/CloudProviderToken/Show.php

@@ -0,0 +1,144 @@
+<?php
+
+namespace App\Livewire\Server\CloudProviderToken;
+
+use App\Models\CloudProviderToken;
+use App\Models\Server;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Livewire\Component;
+
+class Show extends Component
+{
+    use AuthorizesRequests;
+
+    public Server $server;
+
+    public $cloudProviderTokens = [];
+
+    public $parameters = [];
+
+    public function mount(string $server_uuid)
+    {
+        try {
+            $this->server = Server::ownedByCurrentTeam()->whereUuid($server_uuid)->firstOrFail();
+            $this->loadTokens();
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function getListeners()
+    {
+        return [
+            'tokenAdded' => 'handleTokenAdded',
+        ];
+    }
+
+    public function loadTokens()
+    {
+        $this->cloudProviderTokens = CloudProviderToken::ownedByCurrentTeam()
+            ->where('provider', 'hetzner')
+            ->get();
+    }
+
+    public function handleTokenAdded($tokenId)
+    {
+        $this->loadTokens();
+    }
+
+    public function setCloudProviderToken($tokenId)
+    {
+        $ownedToken = CloudProviderToken::ownedByCurrentTeam()->find($tokenId);
+        if (is_null($ownedToken)) {
+            $this->dispatch('error', 'You are not allowed to use this token.');
+
+            return;
+        }
+        try {
+            $this->authorize('update', $this->server);
+
+            // Validate the token works and can access this specific server
+            $validationResult = $this->validateTokenForServer($ownedToken);
+            if (! $validationResult['valid']) {
+                $this->dispatch('error', $validationResult['error']);
+
+                return;
+            }
+
+            $this->server->cloudProviderToken()->associate($ownedToken);
+            $this->server->save();
+            $this->dispatch('success', 'Hetzner token updated successfully.');
+            $this->dispatch('refreshServerShow');
+        } catch (\Exception $e) {
+            $this->server->refresh();
+            $this->dispatch('error', $e->getMessage());
+        }
+    }
+
+    private function validateTokenForServer(CloudProviderToken $token): array
+    {
+        try {
+            // First, validate the token itself
+            $response = \Illuminate\Support\Facades\Http::withHeaders([
+                'Authorization' => 'Bearer '.$token->token,
+            ])->timeout(10)->get('https://api.hetzner.cloud/v1/servers');
+
+            if (! $response->successful()) {
+                return [
+                    'valid' => false,
+                    'error' => 'This token is invalid or has insufficient permissions.',
+                ];
+            }
+
+            // Check if this token can access the specific Hetzner server
+            if ($this->server->hetzner_server_id) {
+                $serverResponse = \Illuminate\Support\Facades\Http::withHeaders([
+                    'Authorization' => 'Bearer '.$token->token,
+                ])->timeout(10)->get("https://api.hetzner.cloud/v1/servers/{$this->server->hetzner_server_id}");
+
+                if (! $serverResponse->successful()) {
+                    return [
+                        'valid' => false,
+                        'error' => 'This token cannot access this server. It may belong to a different Hetzner project.',
+                    ];
+                }
+            }
+
+            return ['valid' => true];
+        } catch (\Throwable $e) {
+            return [
+                'valid' => false,
+                'error' => 'Failed to validate token: '.$e->getMessage(),
+            ];
+        }
+    }
+
+    public function validateToken()
+    {
+        try {
+            $token = $this->server->cloudProviderToken;
+            if (! $token) {
+                $this->dispatch('error', 'No Hetzner token is associated with this server.');
+
+                return;
+            }
+
+            $response = \Illuminate\Support\Facades\Http::withHeaders([
+                'Authorization' => 'Bearer '.$token->token,
+            ])->timeout(10)->get('https://api.hetzner.cloud/v1/servers');
+
+            if ($response->successful()) {
+                $this->dispatch('success', 'Hetzner token is valid and working.');
+            } else {
+                $this->dispatch('error', 'Hetzner token is invalid or has insufficient permissions.');
+            }
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function render()
+    {
+        return view('livewire.server.cloud-provider-token.show');
+    }
+}

app/Livewire/Server/Create.php

@@ -2,6 +2,7 @@
 
 namespace App\Livewire\Server;
 
+use App\Models\CloudProviderToken;
 use App\Models\PrivateKey;
 use App\Models\Team;
 use Livewire\Component;
@@ -12,6 +13,8 @@ class Create extends Component
 
     public bool $limit_reached = false;
 
+    public bool $has_hetzner_tokens = false;
+
     public function mount()
     {
         $this->private_keys = PrivateKey::ownedByCurrentTeam()->get();
@@ -21,6 +24,11 @@ public function mount()
             return;
         }
         $this->limit_reached = Team::serverLimitReached();
+
+        // Check if user has Hetzner tokens
+        $this->has_hetzner_tokens = CloudProviderToken::ownedByCurrentTeam()
+            ->where('provider', 'hetzner')
+            ->exists();
     }
 
     public function render()

app/Livewire/Server/Delete.php

@@ -16,6 +16,8 @@ class Delete extends Component
 
     public Server $server;
 
+    public bool $delete_from_hetzner = false;
+
     public function mount(string $server_uuid)
     {
         try {
@@ -41,8 +43,15 @@ public function delete($password)
 
                 return;
             }
+
             $this->server->delete();
-            DeleteServer::dispatch($this->server);
+            DeleteServer::dispatch(
+                $this->server->id,
+                $this->delete_from_hetzner,
+                $this->server->hetzner_server_id,
+                $this->server->cloud_provider_token_id,
+                $this->server->team_id
+            );
 
             return redirect()->route('server.index');
         } catch (\Throwable $e) {
@@ -52,6 +61,18 @@ public function delete($password)
 
     public function render()
     {
-        return view('livewire.server.delete');
+        $checkboxes = [];
+
+        if ($this->server->hetzner_server_id) {
+            $checkboxes[] = [
+                'id' => 'delete_from_hetzner',
+                'label' => 'Also delete server from Hetzner Cloud',
+                'default_warning' => 'The actual server on Hetzner Cloud will NOT be deleted.',
+            ];
+        }
+
+        return view('livewire.server.delete', [
+            'checkboxes' => $checkboxes,
+        ]);
     }
 }

app/Livewire/Server/Navbar.php

@@ -118,17 +118,31 @@ public function checkProxyStatus()
 
     public function showNotification()
     {
+        $this->server->refresh();
         $this->proxyStatus = $this->server->proxy->status ?? 'unknown';
-        $forceStop = $this->server->proxy->force_stop ?? false;
 
         switch ($this->proxyStatus) {
             case 'running':
                 $this->loadProxyConfiguration();
+                $this->dispatch('success', 'Proxy is running.');
                 break;
             case 'restarting':
                 $this->dispatch('info', 'Initiating proxy restart.');
                 break;
+            case 'exited':
+                $this->dispatch('info', 'Proxy has exited.');
+                break;
+            case 'stopping':
+                $this->dispatch('info', 'Proxy is stopping.');
+                break;
+            case 'starting':
+                $this->dispatch('info', 'Proxy is starting.');
+                break;
+            case 'unknown':
+                $this->dispatch('info', 'Proxy status is unknown.');
+                break;
             default:
+                $this->dispatch('info', 'Proxy status updated.');
                 break;
         }
 

app/Livewire/Server/New/ByHetzner.php

@@ -0,0 +1,587 @@
+<?php
+
+namespace App\Livewire\Server\New;
+
+use App\Enums\ProxyTypes;
+use App\Models\CloudInitScript;
+use App\Models\CloudProviderToken;
+use App\Models\PrivateKey;
+use App\Models\Server;
+use App\Models\Team;
+use App\Rules\ValidHostname;
+use App\Services\HetznerService;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Http;
+use Livewire\Attributes\Locked;
+use Livewire\Component;
+
+class ByHetzner extends Component
+{
+    use AuthorizesRequests;
+
+    // Step tracking
+    public int $current_step = 1;
+
+    // Locked data
+    #[Locked]
+    public Collection $available_tokens;
+
+    #[Locked]
+    public $private_keys;
+
+    #[Locked]
+    public $limit_reached;
+
+    // Step 1: Token selection
+    public ?int $selected_token_id = null;
+
+    // Step 2: Server configuration
+    public array $locations = [];
+
+    public array $images = [];
+
+    public array $serverTypes = [];
+
+    public array $hetznerSshKeys = [];
+
+    public ?string $selected_location = null;
+
+    public ?int $selected_image = null;
+
+    public ?string $selected_server_type = null;
+
+    public array $selectedHetznerSshKeyIds = [];
+
+    public string $server_name = '';
+
+    public ?int $private_key_id = null;
+
+    public bool $loading_data = false;
+
+    public bool $enable_ipv4 = true;
+
+    public bool $enable_ipv6 = true;
+
+    public ?string $cloud_init_script = null;
+
+    public bool $save_cloud_init_script = false;
+
+    public ?string $cloud_init_script_name = null;
+
+    public ?int $selected_cloud_init_script_id = null;
+
+    #[Locked]
+    public Collection $saved_cloud_init_scripts;
+
+    public function mount()
+    {
+        $this->authorize('viewAny', CloudProviderToken::class);
+        $this->loadTokens();
+        $this->loadSavedCloudInitScripts();
+        $this->server_name = generate_random_name();
+        if ($this->private_keys->count() > 0) {
+            $this->private_key_id = $this->private_keys->first()->id;
+        }
+    }
+
+    public function loadSavedCloudInitScripts()
+    {
+        $this->saved_cloud_init_scripts = CloudInitScript::ownedByCurrentTeam()->get();
+    }
+
+    public function getListeners()
+    {
+        return [
+            'tokenAdded' => 'handleTokenAdded',
+            'privateKeyCreated' => 'handlePrivateKeyCreated',
+            'modalClosed' => 'resetSelection',
+        ];
+    }
+
+    public function resetSelection()
+    {
+        $this->selected_token_id = null;
+        $this->current_step = 1;
+        $this->cloud_init_script = null;
+        $this->save_cloud_init_script = false;
+        $this->cloud_init_script_name = null;
+        $this->selected_cloud_init_script_id = null;
+    }
+
+    public function loadTokens()
+    {
+        $this->available_tokens = CloudProviderToken::ownedByCurrentTeam()
+            ->where('provider', 'hetzner')
+            ->get();
+    }
+
+    public function handleTokenAdded($tokenId)
+    {
+        // Refresh token list
+        $this->loadTokens();
+
+        // Auto-select the new token
+        $this->selected_token_id = $tokenId;
+
+        // Automatically proceed to next step
+        $this->nextStep();
+    }
+
+    public function handlePrivateKeyCreated($keyId)
+    {
+        // Refresh private keys list
+        $this->private_keys = PrivateKey::ownedByCurrentTeam()->get();
+
+        // Auto-select the new key
+        $this->private_key_id = $keyId;
+
+        // Clear validation errors for private_key_id
+        $this->resetErrorBag('private_key_id');
+    }
+
+    protected function rules(): array
+    {
+        $rules = [
+            'selected_token_id' => 'required|integer|exists:cloud_provider_tokens,id',
+        ];
+
+        if ($this->current_step === 2) {
+            $rules = array_merge($rules, [
+                'server_name' => ['required', 'string', 'max:253', new ValidHostname],
+                'selected_location' => 'required|string',
+                'selected_image' => 'required|integer',
+                'selected_server_type' => 'required|string',
+                'private_key_id' => 'required|integer|exists:private_keys,id,team_id,'.currentTeam()->id,
+                'selectedHetznerSshKeyIds' => 'nullable|array',
+                'selectedHetznerSshKeyIds.*' => 'integer',
+                'enable_ipv4' => 'required|boolean',
+                'enable_ipv6' => 'required|boolean',
+                'cloud_init_script' => ['nullable', 'string', new \App\Rules\ValidCloudInitYaml],
+                'save_cloud_init_script' => 'boolean',
+                'cloud_init_script_name' => 'nullable|string|max:255',
+                'selected_cloud_init_script_id' => 'nullable|integer|exists:cloud_init_scripts,id',
+            ]);
+        }
+
+        return $rules;
+    }
+
+    protected function messages(): array
+    {
+        return [
+            'selected_token_id.required' => 'Please select a Hetzner token.',
+            'selected_token_id.exists' => 'Selected token not found.',
+        ];
+    }
+
+    public function selectToken(int $tokenId)
+    {
+        $this->selected_token_id = $tokenId;
+    }
+
+    private function validateHetznerToken(string $token): bool
+    {
+        try {
+            $response = Http::withHeaders([
+                'Authorization' => 'Bearer '.$token,
+            ])->timeout(10)->get('https://api.hetzner.cloud/v1/servers');
+
+            return $response->successful();
+        } catch (\Throwable $e) {
+            return false;
+        }
+    }
+
+    private function getHetznerToken(): string
+    {
+        if ($this->selected_token_id) {
+            $token = $this->available_tokens->firstWhere('id', $this->selected_token_id);
+
+            return $token ? $token->token : '';
+        }
+
+        return '';
+    }
+
+    public function nextStep()
+    {
+        // Validate step 1 - just need a token selected
+        $this->validate([
+            'selected_token_id' => 'required|integer|exists:cloud_provider_tokens,id',
+        ]);
+
+        try {
+            $hetznerToken = $this->getHetznerToken();
+
+            if (! $hetznerToken) {
+                return $this->dispatch('error', 'Please select a valid Hetzner token.');
+            }
+
+            // Load Hetzner data
+            $this->loadHetznerData($hetznerToken);
+
+            // Move to step 2
+            $this->current_step = 2;
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function previousStep()
+    {
+        $this->current_step = 1;
+    }
+
+    private function loadHetznerData(string $token)
+    {
+        $this->loading_data = true;
+
+        try {
+            $hetznerService = new HetznerService($token);
+
+            $this->locations = $hetznerService->getLocations();
+            $this->serverTypes = $hetznerService->getServerTypes();
+
+            // Get images and sort by name
+            $images = $hetznerService->getImages();
+
+            ray('Raw images from Hetzner API', [
+                'total_count' => count($images),
+                'types' => collect($images)->pluck('type')->unique()->values(),
+                'sample' => array_slice($images, 0, 3),
+            ]);
+
+            $this->images = collect($images)
+                ->filter(function ($image) {
+                    // Only system images
+                    if (! isset($image['type']) || $image['type'] !== 'system') {
+                        return false;
+                    }
+
+                    // Filter out deprecated images
+                    if (isset($image['deprecated']) && $image['deprecated'] === true) {
+                        return false;
+                    }
+
+                    return true;
+                })
+                ->sortBy('name')
+                ->values()
+                ->toArray();
+
+            ray('Filtered images', [
+                'filtered_count' => count($this->images),
+                'debian_images' => collect($this->images)->filter(fn ($img) => str_contains($img['name'] ?? '', 'debian'))->values(),
+            ]);
+
+            // Load SSH keys from Hetzner
+            $this->hetznerSshKeys = $hetznerService->getSshKeys();
+
+            ray('Hetzner SSH Keys', [
+                'total_count' => count($this->hetznerSshKeys),
+                'keys' => $this->hetznerSshKeys,
+            ]);
+
+            $this->loading_data = false;
+        } catch (\Throwable $e) {
+            $this->loading_data = false;
+            throw $e;
+        }
+    }
+
+    private function getCpuVendorInfo(array $serverType): ?string
+    {
+        $name = strtolower($serverType['name'] ?? '');
+
+        if (str_starts_with($name, 'ccx')) {
+            return 'AMD Milan EPYC™';
+        } elseif (str_starts_with($name, 'cpx')) {
+            return 'AMD EPYC™';
+        } elseif (str_starts_with($name, 'cx')) {
+            return 'Intel® Xeon®';
+        } elseif (str_starts_with($name, 'cax')) {
+            return 'Ampere® Altra®';
+        }
+
+        return null;
+    }
+
+    public function getAvailableServerTypesProperty()
+    {
+        ray('Getting available server types', [
+            'selected_location' => $this->selected_location,
+            'total_server_types' => count($this->serverTypes),
+        ]);
+
+        if (! $this->selected_location) {
+            return $this->serverTypes;
+        }
+
+        $filtered = collect($this->serverTypes)
+            ->filter(function ($type) {
+                if (! isset($type['locations'])) {
+                    return false;
+                }
+
+                $locationNames = collect($type['locations'])->pluck('name')->toArray();
+
+                return in_array($this->selected_location, $locationNames);
+            })
+            ->map(function ($serverType) {
+                $serverType['cpu_vendor_info'] = $this->getCpuVendorInfo($serverType);
+
+                return $serverType;
+            })
+            ->values()
+            ->toArray();
+
+        ray('Filtered server types', [
+            'selected_location' => $this->selected_location,
+            'filtered_count' => count($filtered),
+        ]);
+
+        return $filtered;
+    }
+
+    public function getAvailableImagesProperty()
+    {
+        ray('Getting available images', [
+            'selected_server_type' => $this->selected_server_type,
+            'total_images' => count($this->images),
+            'images' => $this->images,
+        ]);
+
+        if (! $this->selected_server_type) {
+            return $this->images;
+        }
+
+        $serverType = collect($this->serverTypes)->firstWhere('name', $this->selected_server_type);
+
+        ray('Server type data', $serverType);
+
+        if (! $serverType || ! isset($serverType['architecture'])) {
+            ray('No architecture in server type, returning all');
+
+            return $this->images;
+        }
+
+        $architecture = $serverType['architecture'];
+
+        $filtered = collect($this->images)
+            ->filter(fn ($image) => ($image['architecture'] ?? null) === $architecture)
+            ->values()
+            ->toArray();
+
+        ray('Filtered images', [
+            'architecture' => $architecture,
+            'filtered_count' => count($filtered),
+        ]);
+
+        return $filtered;
+    }
+
+    public function getSelectedServerPriceProperty(): ?string
+    {
+        if (! $this->selected_server_type) {
+            return null;
+        }
+
+        $serverType = collect($this->serverTypes)->firstWhere('name', $this->selected_server_type);
+
+        if (! $serverType || ! isset($serverType['prices'][0]['price_monthly']['gross'])) {
+            return null;
+        }
+
+        $price = $serverType['prices'][0]['price_monthly']['gross'];
+
+        return '€'.number_format($price, 2);
+    }
+
+    public function updatedSelectedLocation($value)
+    {
+        ray('Location selected', $value);
+
+        // Reset server type and image when location changes
+        $this->selected_server_type = null;
+        $this->selected_image = null;
+    }
+
+    public function updatedSelectedServerType($value)
+    {
+        ray('Server type selected', $value);
+
+        // Reset image when server type changes
+        $this->selected_image = null;
+    }
+
+    public function updatedSelectedImage($value)
+    {
+        ray('Image selected', $value);
+    }
+
+    public function updatedSelectedCloudInitScriptId($value)
+    {
+        if ($value) {
+            $script = CloudInitScript::ownedByCurrentTeam()->findOrFail($value);
+            $this->cloud_init_script = $script->script;
+            $this->cloud_init_script_name = $script->name;
+        }
+    }
+
+    public function clearCloudInitScript()
+    {
+        $this->selected_cloud_init_script_id = null;
+        $this->cloud_init_script = '';
+        $this->cloud_init_script_name = '';
+        $this->save_cloud_init_script = false;
+    }
+
+    private function createHetznerServer(string $token): array
+    {
+        $hetznerService = new HetznerService($token);
+
+        // Get the private key and extract public key
+        $privateKey = PrivateKey::ownedByCurrentTeam()->findOrFail($this->private_key_id);
+
+        $publicKey = $privateKey->getPublicKey();
+        $md5Fingerprint = PrivateKey::generateMd5Fingerprint($privateKey->private_key);
+
+        ray('Private Key Info', [
+            'private_key_id' => $this->private_key_id,
+            'sha256_fingerprint' => $privateKey->fingerprint,
+            'md5_fingerprint' => $md5Fingerprint,
+        ]);
+
+        // Check if SSH key already exists on Hetzner by comparing MD5 fingerprints
+        $existingSshKeys = $hetznerService->getSshKeys();
+        $existingKey = null;
+
+        ray('Existing SSH Keys on Hetzner', $existingSshKeys);
+
+        foreach ($existingSshKeys as $key) {
+            if ($key['fingerprint'] === $md5Fingerprint) {
+                $existingKey = $key;
+                break;
+            }
+        }
+
+        // Upload SSH key if it doesn't exist
+        if ($existingKey) {
+            $sshKeyId = $existingKey['id'];
+            ray('Using existing SSH key', ['ssh_key_id' => $sshKeyId]);
+        } else {
+            $sshKeyName = $privateKey->name;
+            $uploadedKey = $hetznerService->uploadSshKey($sshKeyName, $publicKey);
+            $sshKeyId = $uploadedKey['id'];
+            ray('Uploaded new SSH key', ['ssh_key_id' => $sshKeyId, 'name' => $sshKeyName]);
+        }
+
+        // Normalize server name to lowercase for RFC 1123 compliance
+        $normalizedServerName = strtolower(trim($this->server_name));
+
+        // Prepare SSH keys array: Coolify key + user-selected Hetzner keys
+        $sshKeys = array_merge(
+            [$sshKeyId], // Coolify key (always included)
+            $this->selectedHetznerSshKeyIds // User-selected Hetzner keys
+        );
+
+        // Remove duplicates in case the Coolify key was also selected
+        $sshKeys = array_unique($sshKeys);
+        $sshKeys = array_values($sshKeys); // Re-index array
+
+        // Prepare server creation parameters
+        $params = [
+            'name' => $normalizedServerName,
+            'server_type' => $this->selected_server_type,
+            'image' => $this->selected_image,
+            'location' => $this->selected_location,
+            'start_after_create' => true,
+            'ssh_keys' => $sshKeys,
+            'public_net' => [
+                'enable_ipv4' => $this->enable_ipv4,
+                'enable_ipv6' => $this->enable_ipv6,
+            ],
+        ];
+
+        // Add cloud-init script if provided
+        if (! empty($this->cloud_init_script)) {
+            $params['user_data'] = $this->cloud_init_script;
+        }
+
+        ray('Server creation parameters', $params);
+
+        // Create server on Hetzner
+        $hetznerServer = $hetznerService->createServer($params);
+
+        ray('Hetzner server created', $hetznerServer);
+
+        return $hetznerServer;
+    }
+
+    public function submit()
+    {
+        $this->validate();
+
+        try {
+            $this->authorize('create', Server::class);
+
+            if (Team::serverLimitReached()) {
+                return $this->dispatch('error', 'You have reached the server limit for your subscription.');
+            }
+
+            // Save cloud-init script if requested
+            if ($this->save_cloud_init_script && ! empty($this->cloud_init_script) && ! empty($this->cloud_init_script_name)) {
+                $this->authorize('create', CloudInitScript::class);
+
+                CloudInitScript::create([
+                    'team_id' => currentTeam()->id,
+                    'name' => $this->cloud_init_script_name,
+                    'script' => $this->cloud_init_script,
+                ]);
+            }
+
+            $hetznerToken = $this->getHetznerToken();
+
+            // Create server on Hetzner
+            $hetznerServer = $this->createHetznerServer($hetznerToken);
+
+            // Determine IP address to use (prefer IPv4, fallback to IPv6)
+            $ipAddress = null;
+            if ($this->enable_ipv4 && isset($hetznerServer['public_net']['ipv4']['ip'])) {
+                $ipAddress = $hetznerServer['public_net']['ipv4']['ip'];
+            } elseif ($this->enable_ipv6 && isset($hetznerServer['public_net']['ipv6']['ip'])) {
+                $ipAddress = $hetznerServer['public_net']['ipv6']['ip'];
+            }
+
+            if (! $ipAddress) {
+                throw new \Exception('No public IP address available. Enable at least one of IPv4 or IPv6.');
+            }
+
+            // Create server in Coolify database
+            $server = Server::create([
+                'name' => $this->server_name,
+                'ip' => $ipAddress,
+                'user' => 'root',
+                'port' => 22,
+                'team_id' => currentTeam()->id,
+                'private_key_id' => $this->private_key_id,
+                'cloud_provider_token_id' => $this->selected_token_id,
+                'hetzner_server_id' => $hetznerServer['id'],
+            ]);
+
+            $server->proxy->set('status', 'exited');
+            $server->proxy->set('type', ProxyTypes::TRAEFIK->value);
+            $server->save();
+
+            return redirect()->route('server.show', $server->uuid);
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function render()
+    {
+        return view('livewire.server.new.by-hetzner');
+    }
+}

app/Livewire/Server/Proxy.php

@@ -22,6 +22,8 @@ class Proxy extends Component
 
     public ?string $redirectUrl = null;
 
+    public bool $generateExactLabels = false;
+
     public function getListeners()
     {
         $teamId = auth()->user()->currentTeam()->id;
@@ -33,7 +35,7 @@ public function getListeners()
     }
 
     protected $rules = [
-        'server.settings.generate_exact_labels' => 'required|boolean',
+        'generateExactLabels' => 'required|boolean',
     ];
 
     public function mount()
@@ -41,6 +43,16 @@ public function mount()
         $this->selectedProxy = $this->server->proxyType();
         $this->redirectEnabled = data_get($this->server, 'proxy.redirect_enabled', true);
         $this->redirectUrl = data_get($this->server, 'proxy.redirect_url');
+        $this->syncData(false);
+    }
+
+    private function syncData(bool $toModel = false): void
+    {
+        if ($toModel) {
+            $this->server->settings->generate_exact_labels = $this->generateExactLabels;
+        } else {
+            $this->generateExactLabels = $this->server->settings->generate_exact_labels ?? false;
+        }
     }
 
     public function getConfigurationFilePathProperty()
@@ -75,6 +87,7 @@ public function instantSave()
         try {
             $this->authorize('update', $this->server);
             $this->validate();
+            $this->syncData(true);
             $this->server->settings->save();
             $this->dispatch('success', 'Settings saved.');
         } catch (\Throwable $e) {

app/Livewire/Server/Show.php

@@ -67,13 +67,21 @@ class Show extends Component
 
     public string $serverTimezone;
 
+    public ?string $hetznerServerStatus = null;
+
+    public bool $hetznerServerManuallyStarted = false;
+
+    public bool $isValidating = false;
+
     public function getListeners()
     {
         $teamId = $this->server->team_id ?? auth()->user()->currentTeam()->id;
 
         return [
             'refreshServerShow' => 'refresh',
+            'refreshServer' => '$refresh',
             "echo-private:team.{$teamId},SentinelRestarted" => 'handleSentinelRestarted',
+            "echo-private:team.{$teamId},ServerValidated" => 'handleServerValidated',
         ];
     }
 
@@ -138,6 +146,10 @@ public function mount(string $server_uuid)
             if (! $this->server->isEmpty()) {
                 $this->isBuildServerLocked = true;
             }
+            // Load saved Hetzner status and validation state
+            $this->hetznerServerStatus = $this->server->hetzner_server_status;
+            $this->isValidating = $this->server->is_validating ?? false;
+
         } catch (\Throwable $e) {
             return handleError($e, $this);
         }
@@ -218,6 +230,7 @@ public function syncData(bool $toModel = false)
             $this->isSentinelDebugEnabled = $this->server->settings->is_sentinel_debug_enabled;
             $this->sentinelUpdatedAt = $this->server->sentinel_updated_at;
             $this->serverTimezone = $this->server->settings->server_timezone;
+            $this->isValidating = $this->server->is_validating ?? false;
         }
     }
 
@@ -361,6 +374,87 @@ public function instantSave()
         }
     }
 
+    public function checkHetznerServerStatus(bool $manual = false)
+    {
+        try {
+            if (! $this->server->hetzner_server_id || ! $this->server->cloudProviderToken) {
+                $this->dispatch('error', 'This server is not associated with a Hetzner Cloud server or token.');
+
+                return;
+            }
+
+            $hetznerService = new \App\Services\HetznerService($this->server->cloudProviderToken->token);
+            $serverData = $hetznerService->getServer($this->server->hetzner_server_id);
+
+            $this->hetznerServerStatus = $serverData['status'] ?? null;
+
+            // Save status to database without triggering model events
+            if ($this->server->hetzner_server_status !== $this->hetznerServerStatus) {
+                $this->server->hetzner_server_status = $this->hetznerServerStatus;
+                $this->server->update(['hetzner_server_status' => $this->hetznerServerStatus]);
+            }
+            if ($manual) {
+                $this->dispatch('success', 'Server status refreshed: '.ucfirst($this->hetznerServerStatus ?? 'unknown'));
+            }
+
+            // If Hetzner server is off but Coolify thinks it's still reachable, update Coolify's state
+            if ($this->hetznerServerStatus === 'off' && $this->server->settings->is_reachable) {
+                ['uptime' => $uptime, 'error' => $error] = $this->server->validateConnection();
+                if ($uptime) {
+                    $this->dispatch('success', 'Server is reachable.');
+                    $this->server->settings->is_reachable = $this->isReachable = true;
+                    $this->server->settings->is_usable = $this->isUsable = true;
+                    $this->server->settings->save();
+                    ServerReachabilityChanged::dispatch($this->server);
+                } else {
+                    $this->dispatch('error', 'Server is not reachable.', 'Please validate your configuration and connection.<br><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);
+
+                    return;
+                }
+            }
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
+    public function handleServerValidated($event = null)
+    {
+        // Check if event is for this server
+        if ($event && isset($event['serverUuid']) && $event['serverUuid'] !== $this->server->uuid) {
+            return;
+        }
+
+        // Refresh server data
+        $this->server->refresh();
+        $this->syncData();
+
+        // Update validation state
+        $this->isValidating = $this->server->is_validating ?? false;
+        $this->dispatch('refreshServerShow');
+        $this->dispatch('refreshServer');
+    }
+
+    public function startHetznerServer()
+    {
+        try {
+            if (! $this->server->hetzner_server_id || ! $this->server->cloudProviderToken) {
+                $this->dispatch('error', 'This server is not associated with a Hetzner Cloud server or token.');
+
+                return;
+            }
+
+            $hetznerService = new \App\Services\HetznerService($this->server->cloudProviderToken->token);
+            $hetznerService->powerOnServer($this->server->hetzner_server_id);
+
+            $this->hetznerServerStatus = 'starting';
+            $this->server->update(['hetzner_server_status' => 'starting']);
+            $this->hetznerServerManuallyStarted = true; // Set flag to trigger auto-validation when running
+            $this->dispatch('success', 'Hetzner server is starting...');
+        } catch (\Throwable $e) {
+            return handleError($e, $this);
+        }
+    }
+
     public function submit()
     {
         try {

app/Livewire/Server/ValidateAndInstall.php

@@ -4,6 +4,7 @@
 
 use App\Actions\Proxy\CheckProxy;
 use App\Actions\Proxy\StartProxy;
+use App\Events\ServerValidated;
 use App\Models\Server;
 use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
 use Livewire\Component;
@@ -63,6 +64,19 @@ public function startValidatingAfterAsking()
         $this->init();
     }
 
+    public function retry()
+    {
+        $this->authorize('update', $this->server);
+        $this->uptime = null;
+        $this->supported_os_type = null;
+        $this->docker_installed = null;
+        $this->docker_compose_installed = null;
+        $this->docker_version = null;
+        $this->error = null;
+        $this->number_of_tries = 0;
+        $this->init();
+    }
+
     public function validateConnection()
     {
         $this->authorize('update', $this->server);
@@ -136,8 +150,12 @@ public function validateDockerVersion()
         } else {
             $this->docker_version = $this->server->validateDockerEngineVersion();
             if ($this->docker_version) {
+                // Mark validation as complete
+                $this->server->update(['is_validating' => false]);
+
                 $this->dispatch('refreshServerShow');
                 $this->dispatch('refreshBoardingIndex');
+                ServerValidated::dispatch($this->server->team_id, $this->server->uuid);
                 $this->dispatch('success', 'Server validated, proxy is starting in a moment.');
                 $proxyShouldRun = CheckProxy::run($this->server, true);
                 if (! $proxyShouldRun) {

app/Livewire/Source/Github/Change.php

@@ -34,32 +34,60 @@ class Change extends Component
 
     public ?GithubApp $github_app = null;
 
+    // Explicit properties
     public string $name;
 
-    public bool $is_system_wide;
+    public ?string $organization = null;
+
+    public string $apiUrl;
+
+    public string $htmlUrl;
+
+    public string $customUser;
+
+    public int $customPort;
+
+    public int $appId;
+
+    public int $installationId;
+
+    public string $clientId;
+
+    public string $clientSecret;
+
+    public string $webhookSecret;
+
+    public bool $isSystemWide;
+
+    public int $privateKeyId;
+
+    public ?string $contents = null;
+
+    public ?string $metadata = null;
+
+    public ?string $pullRequests = null;
 
     public $applications;
 
     public $privateKeys;
 
     protected $rules = [
-        'github_app.name' => 'required|string',
-        'github_app.organization' => 'nullable|string',
-        'github_app.api_url' => 'required|string',
-        'github_app.html_url' => 'required|string',
-        'github_app.custom_user' => 'required|string',
-        'github_app.custom_port' => 'required|int',
-        'github_app.app_id' => 'required|int',
-        'github_app.installation_id' => 'required|int',
-        'github_app.client_id' => 'required|string',
-        'github_app.client_secret' => 'required|string',
-        'github_app.webhook_secret' => 'required|string',
-        'github_app.is_system_wide' => 'required|bool',
-        'github_app.contents' => 'nullable|string',
-        'github_app.metadata' => 'nullable|string',
-        'github_app.pull_requests' => 'nullable|string',
-        'github_app.administration' => 'nullable|string',
-        'github_app.private_key_id' => 'required|int',
+        'name' => 'required|string',
+        'organization' => 'nullable|string',
+        'apiUrl' => 'required|string',
+        'htmlUrl' => 'required|string',
+        'customUser' => 'required|string',
+        'customPort' => 'required|int',
+        'appId' => 'required|int',
+        'installationId' => 'required|int',
+        'clientId' => 'required|string',
+        'clientSecret' => 'required|string',
+        'webhookSecret' => 'required|string',
+        'isSystemWide' => 'required|bool',
+        'contents' => 'nullable|string',
+        'metadata' => 'nullable|string',
+        'pullRequests' => 'nullable|string',
+        'privateKeyId' => 'required|int',
     ];
 
     public function boot()
@@ -69,6 +97,52 @@ public function boot()
         }
     }
 
+    /**
+     * 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->github_app->name = $this->name;
+            $this->github_app->organization = $this->organization;
+            $this->github_app->api_url = $this->apiUrl;
+            $this->github_app->html_url = $this->htmlUrl;
+            $this->github_app->custom_user = $this->customUser;
+            $this->github_app->custom_port = $this->customPort;
+            $this->github_app->app_id = $this->appId;
+            $this->github_app->installation_id = $this->installationId;
+            $this->github_app->client_id = $this->clientId;
+            $this->github_app->client_secret = $this->clientSecret;
+            $this->github_app->webhook_secret = $this->webhookSecret;
+            $this->github_app->is_system_wide = $this->isSystemWide;
+            $this->github_app->private_key_id = $this->privateKeyId;
+            $this->github_app->contents = $this->contents;
+            $this->github_app->metadata = $this->metadata;
+            $this->github_app->pull_requests = $this->pullRequests;
+        } else {
+            // Sync FROM model (on load/refresh)
+            $this->name = $this->github_app->name;
+            $this->organization = $this->github_app->organization;
+            $this->apiUrl = $this->github_app->api_url;
+            $this->htmlUrl = $this->github_app->html_url;
+            $this->customUser = $this->github_app->custom_user;
+            $this->customPort = $this->github_app->custom_port;
+            $this->appId = $this->github_app->app_id;
+            $this->installationId = $this->github_app->installation_id;
+            $this->clientId = $this->github_app->client_id;
+            $this->clientSecret = $this->github_app->client_secret;
+            $this->webhookSecret = $this->github_app->webhook_secret;
+            $this->isSystemWide = $this->github_app->is_system_wide;
+            $this->privateKeyId = $this->github_app->private_key_id;
+            $this->contents = $this->github_app->contents;
+            $this->metadata = $this->github_app->metadata;
+            $this->pullRequests = $this->github_app->pull_requests;
+        }
+    }
+
     public function checkPermissions()
     {
         try {
@@ -126,6 +200,10 @@ public function mount()
             $this->applications = $this->github_app->applications;
             $settings = instanceSettings();
 
+            // Sync data from model to properties
+            $this->syncData(false);
+
+            // Override name with kebab case for display
             $this->name = str($this->github_app->name)->kebab();
             $this->fqdn = $settings->fqdn;
 
@@ -247,21 +325,9 @@ public function submit()
             $this->authorize('update', $this->github_app);
 
             $this->github_app->makeVisible('client_secret')->makeVisible('webhook_secret');
-            $this->validate([
-                'github_app.name' => 'required|string',
-                'github_app.organization' => 'nullable|string',
-                'github_app.api_url' => 'required|string',
-                'github_app.html_url' => 'required|string',
-                'github_app.custom_user' => 'required|string',
-                'github_app.custom_port' => 'required|int',
-                'github_app.app_id' => 'required|int',
-                'github_app.installation_id' => 'required|int',
-                'github_app.client_id' => 'required|string',
-                'github_app.client_secret' => 'required|string',
-                'github_app.webhook_secret' => 'required|string',
-                'github_app.is_system_wide' => 'required|bool',
-                'github_app.private_key_id' => 'required|int',
-            ]);
+            $this->validate();
+
+            $this->syncData(true);
             $this->github_app->save();
             $this->dispatch('success', 'Github App updated.');
         } catch (\Throwable $e) {
@@ -286,6 +352,8 @@ public function instantSave()
             $this->authorize('update', $this->github_app);
 
             $this->github_app->makeVisible('client_secret')->makeVisible('webhook_secret');
+
+            $this->syncData(true);
             $this->github_app->save();
             $this->dispatch('success', 'Github App updated.');
         } catch (\Throwable $e) {

app/Livewire/Storage/Form.php

@@ -14,17 +14,34 @@ class Form extends Component
 
     public S3Storage $storage;
 
+    // Explicit properties
+    public ?string $name = null;
+
+    public ?string $description = null;
+
+    public string $endpoint;
+
+    public string $bucket;
+
+    public string $region;
+
+    public string $key;
+
+    public string $secret;
+
+    public ?bool $isUsable = null;
+
     protected function rules(): array
     {
         return [
-            'storage.is_usable' => 'nullable|boolean',
-            'storage.name' => ValidationPatterns::nameRules(required: false),
-            'storage.description' => ValidationPatterns::descriptionRules(),
-            'storage.region' => 'required|max:255',
-            'storage.key' => 'required|max:255',
-            'storage.secret' => 'required|max:255',
-            'storage.bucket' => 'required|max:255',
-            'storage.endpoint' => 'required|url|max:255',
+            'isUsable' => 'nullable|boolean',
+            'name' => ValidationPatterns::nameRules(required: false),
+            'description' => ValidationPatterns::descriptionRules(),
+            'region' => 'required|max:255',
+            'key' => 'required|max:255',
+            'secret' => 'required|max:255',
+            'bucket' => 'required|max:255',
+            'endpoint' => 'required|url|max:255',
         ];
     }
 
@@ -33,34 +50,69 @@ protected function messages(): array
         return array_merge(
             ValidationPatterns::combinedMessages(),
             [
-                'storage.name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
-                'storage.description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
-                'storage.region.required' => 'The Region field is required.',
-                'storage.region.max' => 'The Region may not be greater than 255 characters.',
-                'storage.key.required' => 'The Access Key field is required.',
-                'storage.key.max' => 'The Access Key may not be greater than 255 characters.',
-                'storage.secret.required' => 'The Secret Key field is required.',
-                'storage.secret.max' => 'The Secret Key may not be greater than 255 characters.',
-                'storage.bucket.required' => 'The Bucket field is required.',
-                'storage.bucket.max' => 'The Bucket may not be greater than 255 characters.',
-                'storage.endpoint.required' => 'The Endpoint field is required.',
-                'storage.endpoint.url' => 'The Endpoint must be a valid URL.',
-                'storage.endpoint.max' => 'The Endpoint may not be greater than 255 characters.',
+                '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.',
+                'region.required' => 'The Region field is required.',
+                'region.max' => 'The Region may not be greater than 255 characters.',
+                'key.required' => 'The Access Key field is required.',
+                'key.max' => 'The Access Key may not be greater than 255 characters.',
+                'secret.required' => 'The Secret Key field is required.',
+                'secret.max' => 'The Secret Key may not be greater than 255 characters.',
+                'bucket.required' => 'The Bucket field is required.',
+                'bucket.max' => 'The Bucket may not be greater than 255 characters.',
+                'endpoint.required' => 'The Endpoint field is required.',
+                'endpoint.url' => 'The Endpoint must be a valid URL.',
+                'endpoint.max' => 'The Endpoint may not be greater than 255 characters.',
             ]
         );
     }
 
     protected $validationAttributes = [
-        'storage.is_usable' => 'Is Usable',
-        'storage.name' => 'Name',
-        'storage.description' => 'Description',
-        'storage.region' => 'Region',
-        'storage.key' => 'Key',
-        'storage.secret' => 'Secret',
-        'storage.bucket' => 'Bucket',
-        'storage.endpoint' => 'Endpoint',
+        'isUsable' => 'Is Usable',
+        'name' => 'Name',
+        'description' => 'Description',
+        'region' => 'Region',
+        'key' => 'Key',
+        'secret' => 'Secret',
+        'bucket' => 'Bucket',
+        'endpoint' => 'Endpoint',
     ];
 
+    /**
+     * 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->storage->name = $this->name;
+            $this->storage->description = $this->description;
+            $this->storage->endpoint = $this->endpoint;
+            $this->storage->bucket = $this->bucket;
+            $this->storage->region = $this->region;
+            $this->storage->key = $this->key;
+            $this->storage->secret = $this->secret;
+            $this->storage->is_usable = $this->isUsable;
+        } else {
+            // Sync FROM model (on load/refresh)
+            $this->name = $this->storage->name;
+            $this->description = $this->storage->description;
+            $this->endpoint = $this->storage->endpoint;
+            $this->bucket = $this->storage->bucket;
+            $this->region = $this->storage->region;
+            $this->key = $this->storage->key;
+            $this->secret = $this->storage->secret;
+            $this->isUsable = $this->storage->is_usable;
+        }
+    }
+
+    public function mount()
+    {
+        $this->syncData(false);
+    }
+
     public function testConnection()
     {
         try {
@@ -94,6 +146,9 @@ public function submit()
 
             DB::transaction(function () {
                 $this->validate();
+
+                // Sync properties to model before saving
+                $this->syncData(true);
                 $this->storage->save();
 
                 // Test connection with new values - if this fails, transaction will rollback
@@ -103,12 +158,16 @@ public function submit()
                 $this->storage->is_usable = true;
                 $this->storage->unusable_email_sent = false;
                 $this->storage->save();
+
+                // Update local property to reflect success
+                $this->isUsable = true;
             });
 
             $this->dispatch('success', 'Storage settings updated and connection verified.');
         } catch (\Throwable $e) {
             // Refresh the model to revert UI to database values after rollback
             $this->storage->refresh();
+            $this->syncData(false);
 
             return handleError($e, $this);
         }

app/Livewire/Team/Index.php

@@ -18,11 +18,16 @@ class Index extends Component
 
     public Team $team;
 
+    // Explicit properties
+    public string $name;
+
+    public ?string $description = null;
+
     protected function rules(): array
     {
         return [
-            'team.name' => ValidationPatterns::nameRules(),
-            'team.description' => ValidationPatterns::descriptionRules(),
+            'name' => ValidationPatterns::nameRules(),
+            'description' => ValidationPatterns::descriptionRules(),
         ];
     }
 
@@ -31,21 +36,40 @@ protected function messages(): array
         return array_merge(
             ValidationPatterns::combinedMessages(),
             [
-                'team.name.required' => 'The Name field is required.',
-                'team.name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
-                'team.description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
+                '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.',
             ]
         );
     }
 
     protected $validationAttributes = [
-        'team.name' => 'name',
-        'team.description' => 'description',
+        'name' => 'name',
+        'description' => 'description',
     ];
 
+    /**
+     * 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->team->name = $this->name;
+            $this->team->description = $this->description;
+        } else {
+            // Sync FROM model (on load/refresh)
+            $this->name = $this->team->name;
+            $this->description = $this->team->description;
+        }
+    }
+
     public function mount()
     {
         $this->team = currentTeam();
+        $this->syncData(false);
 
         if (auth()->user()->isAdminFromSession()) {
             $this->invitations = TeamInvitation::whereTeamId(currentTeam()->id)->get();
@@ -62,6 +86,7 @@ public function submit()
         $this->validate();
         try {
             $this->authorize('update', $this->team);
+            $this->syncData(true);
             $this->team->save();
             refreshSession();
             $this->dispatch('success', 'Team updated.');

app/Livewire/Team/InviteLink.php

@@ -45,9 +45,16 @@ private function generateInviteLink(bool $sendEmail = false)
         try {
             $this->authorize('manageInvitations', currentTeam());
             $this->validate();
-            if (auth()->user()->role() === 'admin' && $this->role === 'owner') {
+
+            // Prevent privilege escalation: users cannot invite someone with higher privileges
+            $userRole = auth()->user()->role();
+            if ($userRole === 'member' && in_array($this->role, ['admin', 'owner'])) {
+                throw new \Exception('Members cannot invite admins or owners.');
+            }
+            if ($userRole === 'admin' && $this->role === 'owner') {
                 throw new \Exception('Admins cannot invite owners.');
             }
+
             $this->email = strtolower($this->email);
 
             $member_emails = currentTeam()->members()->get()->pluck('email');

app/Livewire/Terminal/Index.php

@@ -61,6 +61,10 @@ private function getAllActiveContainers()
 
     public function updatedSelectedUuid()
     {
+        if ($this->selected_uuid === 'default') {
+            // When cleared to default, do nothing (no error message)
+            return;
+        }
         $this->connectToContainer();
     }