feat(v5): add server bootstrap job with realtime cluster broadcasting

- Add V5BootstrapServerJob: SSH into new servers, install coold/WireGuard,
  track bootstrap progress via last_bootstrap_action/status/output fields
- Add V5ClusterUpdated event: broadcasts full cluster+servers payload to
  team private channel on bootstrap state changes
- Add V5RealtimeTestEvent + RealtimeTest page for WebSocket connectivity testing
- Consolidate 3 dropped migrations into base cluster/server migrations:
  WireGuard config, builder CPU quota, status check fields, uuid
- Auto-generate uuid on V5Model create via Schema::hasColumn guard
- Expose currentTeam.id in Inertia shared props
- Add showCluster, realtimeTest, broadcastRealtimeTest controller endpoints
- Add dropdown-menu UI component

app/Events/V5ClusterUpdated.php

@@ -0,0 +1,104 @@
+<?php
+
+namespace App\Events;
+
+use App\Models\V5\Cluster as V5Cluster;
+use App\Models\V5\Server as V5Server;
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Broadcasting\PrivateChannel;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class V5ClusterUpdated implements ShouldBroadcastNow
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public function __construct(public int $teamId, public int $clusterId) {}
+
+    public function broadcastOn(): array
+    {
+        return [
+            new PrivateChannel("team.{$this->teamId}"),
+        ];
+    }
+
+    public function broadcastAs(): string
+    {
+        return 'v5.cluster.updated';
+    }
+
+    /**
+     * @return array{cluster: array<string, mixed>|null}
+     */
+    public function broadcastWith(): array
+    {
+        $cluster = V5Cluster::query()
+            ->where('team_id', $this->teamId)
+            ->with(['servers' => fn ($query) => $query
+                ->with('privateKey')
+                ->orderBy('name')])
+            ->withCount('servers')
+            ->find($this->clusterId);
+
+        return [
+            'cluster' => $cluster instanceof V5Cluster ? $this->serializeCluster($cluster) : null,
+        ];
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function serializeCluster(V5Cluster $cluster): array
+    {
+        return [
+            'id' => (string) $cluster->id,
+            'name' => $cluster->name,
+            'description' => $cluster->description,
+            'wireguardInterface' => $cluster->wireguard_interface,
+            'wireguardManagementPool' => $cluster->wireguard_management_pool,
+            'wireguardListenPort' => $cluster->wireguard_listen_port,
+            'containerNetworkPool' => $cluster->container_network_pool,
+            'containerNetworkPrefix' => $cluster->container_network_prefix,
+            'namespaces' => $cluster->namespaces ?? V5Cluster::DEFAULT_NAMESPACES,
+            'defaultDenyContainers' => $cluster->default_deny_containers,
+            'cooldVersion' => $cluster->coold_version,
+            'corrosionVersion' => $cluster->corrosion_version,
+            'corrosionGossipPort' => $cluster->corrosion_gossip_port,
+            'corrosionApiPort' => $cluster->corrosion_api_port,
+            'builderEnabled' => $cluster->builder_enabled,
+            'builderCapacity' => $cluster->builder_capacity,
+            'builderCpuQuota' => $cluster->builder_cpu_quota,
+            'builderMemoryMax' => $cluster->builder_memory_max,
+            'builderTimeoutSecs' => $cluster->builder_timeout_secs,
+            'lastCliAction' => $cluster->last_cli_action,
+            'lastCliStatus' => $cluster->last_cli_status,
+            'lastCliSummary' => $cluster->last_cli_summary,
+            'lastCliRanAt' => $cluster->last_cli_ran_at?->toJSON(),
+            'serversCount' => $cluster->servers_count ?? $cluster->servers->count(),
+            'servers' => $cluster->servers->map(fn (V5Server $server) => [
+                'id' => (string) $server->id,
+                'name' => $server->name,
+                'host' => $server->host,
+                'status' => $server->status,
+                'capabilities' => $server->capabilities ?? [],
+                'builderEnabled' => $server->builder_enabled,
+                'builderCapacity' => $server->builder_capacity,
+                'builderCpuQuota' => $server->builder_cpu_quota,
+                'uuid' => $server->uuid,
+                'nodeAddress' => $server->node_address,
+                'wireguardListenPortOverride' => $server->wireguard_listen_port_override,
+                'wireguardEndpointOverride' => $server->wireguard_endpoint_override,
+                'wireguardManagementIp' => $server->wireguard_management_ip,
+                'wireguardPublicKey' => $server->wireguard_public_key,
+                'containerSubnets' => $server->container_subnets ?? [],
+                'privateKeyName' => $server->privateKey?->name,
+                'lastBootstrappedAt' => $server->last_bootstrapped_at?->toJSON(),
+                'lastBootstrapAction' => $server->last_bootstrap_action,
+                'lastBootstrapStatus' => $server->last_bootstrap_status,
+                'lastBootstrapOutput' => $server->last_bootstrap_output,
+                'lastBootstrapRanAt' => $server->last_bootstrap_ran_at?->toJSON(),
+            ])->all(),
+        ];
+    }
+}

app/Events/V5RealtimeTestEvent.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Events;
+
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Broadcasting\PrivateChannel;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class V5RealtimeTestEvent implements ShouldBroadcastNow
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public string $sentAt;
+
+    public function __construct(public int $teamId, public string $message)
+    {
+        $this->sentAt = now()->toJSON();
+    }
+
+    public function broadcastOn(): array
+    {
+        return [
+            new PrivateChannel("team.{$this->teamId}"),
+        ];
+    }
+
+    public function broadcastAs(): string
+    {
+        return 'v5.realtime.test';
+    }
+
+    /**
+     * @return array{message: string, teamId: int, sentAt: string}
+     */
+    public function broadcastWith(): array
+    {
+        return [
+            'message' => $this->message,
+            'teamId' => $this->teamId,
+            'sentAt' => $this->sentAt,
+        ];
+    }
+}

app/Http/Controllers/V5/DashboardController.php

@@ -2,7 +2,10 @@
 
 namespace App\Http\Controllers\V5;
 
+use App\Events\V5ClusterUpdated;
+use App\Events\V5RealtimeTestEvent;
 use App\Http\Controllers\Controller;
+use App\Jobs\V5BootstrapServerJob;
 use App\Models\Environment;
 use App\Models\PrivateKey;
 use App\Models\Project;
@@ -55,6 +58,56 @@ class DashboardController extends Controller
         ]);
     }
 
+    public function showCluster(Request $request, V5Cluster $cluster): JsonResponse
+    {
+        $currentTeam = $request->attributes->get('v5.currentTeam');
+
+        if (! $currentTeam instanceof Team || $cluster->team_id !== $currentTeam->id) {
+            abort(404);
+        }
+
+        return response()->json([
+            'cluster' => $this->freshSerializedCluster($cluster),
+        ]);
+    }
+
+    public function realtimeTest(Request $request): Response
+    {
+        $currentTeam = $request->attributes->get('v5.currentTeam');
+
+        if (! $currentTeam instanceof Team) {
+            abort(403);
+        }
+
+        return Inertia::render('RealtimeTest', [
+            'currentTeam' => [
+                'id' => $currentTeam->id,
+            ],
+        ]);
+    }
+
+    public function broadcastRealtimeTest(Request $request): JsonResponse
+    {
+        $currentTeam = $request->attributes->get('v5.currentTeam');
+
+        if (! $currentTeam instanceof Team) {
+            abort(403);
+        }
+
+        $validated = $request->validate([
+            'message' => ['nullable', 'string', 'max:255'],
+        ]);
+
+        V5RealtimeTestEvent::dispatch(
+            $currentTeam->id,
+            $validated['message'] ?? 'Manual v5 realtime test'
+        );
+
+        return response()->json([
+            'message' => 'Realtime test event broadcasted.',
+        ], 202);
+    }
+
     public function updateSelection(Request $request): \Illuminate\Http\Response
     {
         $currentTeam = $request->attributes->get('v5.currentTeam');
@@ -115,7 +168,9 @@ class DashboardController extends Controller
             'corrosion_gossip_port' => ['sometimes', 'integer', 'min:1', 'max:65535'],
             'corrosion_api_port' => ['sometimes', 'integer', 'min:1', 'max:65535'],
             'builder_enabled' => ['sometimes', 'boolean'],
-            'builder_capacity' => ['sometimes', 'integer', 'min:0', 'max:1000'],
+            'builder_capacity' => $this->builderCapacityRules(
+                $this->requestedBuilderEnabled($request, true)
+            ),
             'builder_cpu_quota' => ['sometimes', 'string', 'max:32'],
             'builder_memory_max' => ['sometimes', 'string', 'max:32'],
             'builder_timeout_secs' => ['sometimes', 'integer', 'min:1', 'max:86400'],
@@ -159,12 +214,18 @@ class DashboardController extends Controller
             ], 409);
         }
 
+        if (in_array($server->last_bootstrap_status, ['queued', 'running'], true)) {
+            return response()->json([
+                'cluster' => $this->freshSerializedCluster($cluster),
+                'message' => 'Bootstrap is already queued or running for this server.',
+            ], 409);
+        }
+
         $installedServers = $cluster->servers()
             ->with('privateKey')
             ->whereNotNull('last_bootstrapped_at')
             ->orderBy('name')
             ->get();
-        $action = $installedServers->isEmpty() ? 'bootstrap' : 'extend';
         $server->load('privateKey');
         $servers = $installedServers->toBase()
             ->push($server)
@@ -177,75 +238,20 @@ class DashboardController extends Controller
             ], 422);
         }
 
-        $cluster->update([
-            'last_cli_action' => $action,
-            'last_cli_status' => 'running',
-            'last_cli_summary' => "Starting Coolify CLI {$action} for {$server->name}...",
-            'last_cli_ran_at' => now(),
+        $server->update([
+            'last_bootstrap_action' => $installedServers->isEmpty() ? 'bootstrap' : 'extend',
+            'last_bootstrap_status' => 'queued',
+            'last_bootstrap_output' => "Queued Coolify bootstrap for {$server->name}.",
+            'last_bootstrap_ran_at' => now(),
         ]);
 
-        $keyDirectory = storage_path('app/ssh/keys');
-        if (! is_dir($keyDirectory)) {
-            mkdir($keyDirectory, 0700, true);
-        }
+        V5ClusterUpdated::dispatch($currentTeam->id, $cluster->id);
+        V5BootstrapServerJob::dispatch($cluster->id, $server->id);
 
-        $tempDirectory = $keyDirectory.'/v5_bootstrap_'.str()->random(16);
-        if (! mkdir($tempDirectory, 0700, true) && ! is_dir($tempDirectory)) {
-            $cluster->update([
-                'last_cli_status' => 'failed',
-                'last_cli_summary' => 'Could not create a temporary SSH configuration directory.',
-                'last_cli_ran_at' => now(),
-            ]);
-
-            return response()->json([
-                'cluster' => $this->freshSerializedCluster($cluster),
-            ], 500);
-        }
-
-        try {
-            $sshConfigLocation = $this->writeBootstrapSshConfig($servers, $tempDirectory);
-            $result = Process::timeout(max(60, (int) $cluster->builder_timeout_secs + 120))
-                ->run($this->bootstrapCommand($cluster, $servers, $server, $sshConfigLocation, $action));
-            $output = trim($result->output()."\n".$result->errorOutput());
-            $successful = $result->successful();
-        } catch (\Throwable $e) {
-            $output = $e->getMessage();
-            $successful = false;
-        } finally {
-            $this->deleteDirectory($tempDirectory);
-        }
-
-        $cluster->update([
-            'last_cli_action' => $action,
-            'last_cli_status' => $successful ? 'succeeded' : 'failed',
-            'last_cli_summary' => str($output !== '' ? $output : 'No output returned.')->limit(20000)->toString(),
-            'last_cli_ran_at' => now(),
-        ]);
-
-        if ($successful) {
-            $capabilities = collect($server->capabilities ?? [])
-                ->push('coold')
-                ->when($server->builder_enabled, fn ($capabilities) => $capabilities->push('builder'))
-                ->unique()
-                ->values()
-                ->all();
-
-            $server->update([
-                'status' => 'installed',
-                'capabilities' => $capabilities,
-                'last_bootstrapped_at' => now(),
-            ]);
-        }
-
-        $payload = [
+        return response()->json([
             'cluster' => $this->freshSerializedCluster($cluster),
-        ];
-
-        if (! $successful) {
-            $payload['message'] = $cluster->last_cli_summary;
-        }
-
-        return response()->json($payload, $successful ? 200 : 500);
+            'message' => 'Bootstrap queued.',
+        ], 202);
     }
 
     public function storeServer(Request $request, V5Cluster $cluster): JsonResponse
@@ -275,7 +281,9 @@ class DashboardController extends Controller
             ],
             'node_address' => ['nullable', 'string', 'max:255'],
             'builder_enabled' => ['sometimes', 'boolean'],
-            'builder_capacity' => ['sometimes', 'integer', 'min:0', 'max:1000'],
+            'builder_capacity' => $this->builderCapacityRules(
+                $this->requestedBuilderEnabled($request, $cluster->builder_enabled)
+            ),
             'builder_cpu_quota' => ['sometimes', 'string', 'max:32'],
             'wireguard_listen_port_override' => ['nullable', 'integer', 'min:1', 'max:65535'],
             'wireguard_endpoint_override' => ['nullable', 'string', 'max:255'],
@@ -295,10 +303,10 @@ class DashboardController extends Controller
             'ssh_user' => $validated['ssh_user'],
             'ssh_port' => $validated['ssh_port'],
             'private_key_id' => $validated['private_key_id'] ?? null,
-            'status' => 'pending',
+            'status' => 'added',
             'capabilities' => $builderEnabled ? ['coold', 'builder'] : ['coold'],
             'builder_enabled' => $builderEnabled,
-            'builder_capacity' => $builderEnabled ? $builderCapacity : 0,
+            'builder_capacity' => $builderCapacity,
             'builder_cpu_quota' => $builderCpuQuota,
             'node_address' => $validated['node_address'] ?? $validated['host'],
             'wireguard_listen_port_override' => $validated['wireguard_listen_port_override'] ?? $devWireguardOverrides['listen_port'],
@@ -330,7 +338,10 @@ class DashboardController extends Controller
 
         $validated = $request->validate([
             'builder_enabled' => ['required', 'boolean'],
-            'builder_capacity' => ['required', 'integer', 'min:0', 'max:1000'],
+            'builder_capacity' => $this->builderCapacityRules(
+                $request->boolean('builder_enabled'),
+                required: true
+            ),
             'builder_cpu_quota' => ['required', 'string', 'max:32'],
         ]);
 
@@ -346,7 +357,7 @@ class DashboardController extends Controller
         $server->update([
             'capabilities' => $capabilities,
             'builder_enabled' => $builderEnabled,
-            'builder_capacity' => $builderEnabled ? (int) $validated['builder_capacity'] : 0,
+            'builder_capacity' => (int) $validated['builder_capacity'],
             'builder_cpu_quota' => $validated['builder_cpu_quota'],
         ]);
 
@@ -374,14 +385,10 @@ class DashboardController extends Controller
         }
 
         if (! $server->privateKey instanceof PrivateKey) {
-            $server->update([
-                'last_status_check' => 'failed',
-                'last_status_output' => 'No private key is attached to this server.',
-                'last_status_checked_at' => now(),
-            ]);
-
             return response()->json([
-                'cluster' => $this->freshSerializedCluster($cluster),
+                'status' => 'failed',
+                'output' => 'No private key is attached to this server.',
+                'checkedAt' => now()->toJSON(),
             ]);
         }
 
@@ -392,14 +399,10 @@ class DashboardController extends Controller
 
         $keyLocation = tempnam($keyDirectory, 'v5_ssh_key_');
         if ($keyLocation === false) {
-            $server->update([
-                'last_status_check' => 'failed',
-                'last_status_output' => 'Could not create a temporary SSH key file.',
-                'last_status_checked_at' => now(),
-            ]);
-
             return response()->json([
-                'cluster' => $this->freshSerializedCluster($cluster),
+                'status' => 'failed',
+                'output' => 'Could not create a temporary SSH key file.',
+                'checkedAt' => now()->toJSON(),
             ]);
         }
 
@@ -440,14 +443,10 @@ class DashboardController extends Controller
             @unlink($keyLocation);
         }
 
-        $server->update([
-            'last_status_check' => $status,
-            'last_status_output' => str($output !== '' ? $output : 'No output returned.')->limit(10000)->toString(),
-            'last_status_checked_at' => now(),
-        ]);
-
         return response()->json([
-            'cluster' => $this->freshSerializedCluster($cluster),
+            'status' => $status,
+            'output' => str($output !== '' ? $output : 'No output returned.')->limit(10000)->toString(),
+            'checkedAt' => now()->toJSON(),
         ]);
     }
 
@@ -464,12 +463,6 @@ class DashboardController extends Controller
             abort(404);
         }
 
-        if ($server->last_bootstrapped_at !== null) {
-            return response()->json([
-                'message' => 'Only unbootstrapped servers can be deleted.',
-            ], 409);
-        }
-
         $server->delete();
 
         return response()->json([
@@ -800,6 +793,7 @@ class DashboardController extends Controller
                 'builderEnabled' => $server->builder_enabled,
                 'builderCapacity' => $server->builder_capacity,
                 'builderCpuQuota' => $server->builder_cpu_quota,
+                'uuid' => $server->uuid,
                 'nodeAddress' => $server->node_address,
                 'wireguardListenPortOverride' => $server->wireguard_listen_port_override,
                 'wireguardEndpointOverride' => $server->wireguard_endpoint_override,
@@ -808,9 +802,10 @@ class DashboardController extends Controller
                 'containerSubnets' => $server->container_subnets ?? [],
                 'privateKeyName' => $server->privateKey?->name,
                 'lastBootstrappedAt' => $server->last_bootstrapped_at?->toJSON(),
-                'lastStatusCheck' => $server->last_status_check,
-                'lastStatusOutput' => $server->last_status_output,
-                'lastStatusCheckedAt' => $server->last_status_checked_at?->toJSON(),
+                'lastBootstrapAction' => $server->last_bootstrap_action,
+                'lastBootstrapStatus' => $server->last_bootstrap_status,
+                'lastBootstrapOutput' => $server->last_bootstrap_output,
+                'lastBootstrapRanAt' => $server->last_bootstrap_ran_at?->toJSON(),
             ])->all(),
         ];
     }
@@ -875,6 +870,28 @@ class DashboardController extends Controller
         };
     }
 
+    /**
+     * @return array<int, string>
+     */
+    private function builderCapacityRules(bool $builderEnabled, bool $required = false): array
+    {
+        return [
+            $required ? 'required' : 'sometimes',
+            'integer',
+            $builderEnabled ? 'min:1' : 'min:0',
+            'max:1000',
+        ];
+    }
+
+    private function requestedBuilderEnabled(Request $request, bool $default): bool
+    {
+        if (! $request->has('builder_enabled')) {
+            return $default;
+        }
+
+        return $request->boolean('builder_enabled');
+    }
+
     /**
      * @param  array<int, array{uuid: string, name: string, environments: array<int, array{uuid: string, name: string}>}>  $projects
      * @return array{0: array{uuid: string, name: string, environments: array<int, array{uuid: string, name: string}>}|null, 1: array{uuid: string, name: string}|null}

app/Http/Middleware/V5/HandleInertiaRequests.php

@@ -20,6 +20,9 @@ class HandleInertiaRequests extends Middleware
                     'email' => $request->user()->email,
                 ] : null,
             ],
+            'currentTeam' => $request->attributes->get('v5.currentTeam') ? [
+                'id' => $request->attributes->get('v5.currentTeam')->id,
+            ] : null,
         ];
     }
 }

app/Jobs/V5BootstrapServerJob.php

@@ -0,0 +1,447 @@
+<?php
+
+namespace App\Jobs;
+
+use App\Events\V5ClusterUpdated;
+use App\Models\PrivateKey;
+use App\Models\V5\Cluster as V5Cluster;
+use App\Models\V5\Server as V5Server;
+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\Middleware\WithoutOverlapping;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Process;
+
+class V5BootstrapServerJob implements ShouldBeEncrypted, ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    private const BOOTSTRAP_MARKER_PATH = '/etc/coolify/v5-node.json';
+
+    public int $tries = 1;
+
+    public int $timeout = 7200;
+
+    public function __construct(public int $clusterId, public int $serverId) {}
+
+    /**
+     * @return array<int, object>
+     */
+    public function middleware(): array
+    {
+        return [(new WithoutOverlapping("v5-bootstrap-server-{$this->serverId}"))->expireAfter(7200)->dontRelease()];
+    }
+
+    public function handle(): void
+    {
+        $cluster = V5Cluster::query()->findOrFail($this->clusterId);
+        $server = V5Server::query()->with('privateKey')->findOrFail($this->serverId);
+
+        if ($server->cluster_id !== $cluster->id || $server->last_bootstrapped_at !== null) {
+            return;
+        }
+
+        $installedServers = $cluster->servers()
+            ->with('privateKey')
+            ->whereNotNull('last_bootstrapped_at')
+            ->orderBy('name')
+            ->get();
+        $action = $installedServers->isEmpty() ? 'bootstrap' : 'extend';
+        $servers = $installedServers->toBase()
+            ->push($server)
+            ->unique('id')
+            ->values();
+
+        if ($servers->contains(fn (V5Server $server) => ! $server->privateKey instanceof PrivateKey)) {
+            $this->markFailed($server, $action, 'The new server and every already-bootstrapped server in this cluster must have a private key before extending the cluster.');
+
+            return;
+        }
+
+        $server->update([
+            'last_bootstrap_action' => $action,
+            'last_bootstrap_status' => 'running',
+            'last_bootstrap_output' => "Starting Coolify CLI {$action} for {$server->name}...",
+            'last_bootstrap_ran_at' => now(),
+        ]);
+        $this->broadcastClusterUpdated($server);
+
+        $keyDirectory = storage_path('app/ssh/keys');
+        if (! is_dir($keyDirectory)) {
+            mkdir($keyDirectory, 0700, true);
+        }
+
+        $tempDirectory = $keyDirectory.'/v5_bootstrap_'.str()->random(16);
+        if (! mkdir($tempDirectory, 0700, true) && ! is_dir($tempDirectory)) {
+            $this->markFailed($server, $action, 'Could not create a temporary SSH configuration directory.');
+
+            return;
+        }
+
+        try {
+            $sshConfigLocation = $this->writeBootstrapSshConfig($servers, $tempDirectory);
+            $existingBootstrap = $this->detectExistingBootstrap($server, $sshConfigLocation);
+
+            if (($existingBootstrap['cluster_id'] ?? null) !== null) {
+                if ((string) $existingBootstrap['cluster_id'] !== (string) $cluster->id) {
+                    $this->markFailed($server, $action, 'This server is already bootstrapped for another cluster. Reset the host bootstrap state before joining this cluster.');
+
+                    return;
+                }
+
+                $this->adoptExistingBootstrap($server, $existingBootstrap);
+
+                return;
+            }
+
+            $result = Process::timeout(max(60, (int) $cluster->builder_timeout_secs + 120))
+                ->run($this->bootstrapCommand($cluster, $servers, $server, $sshConfigLocation, $action));
+            $output = trim($result->output()."\n".$result->errorOutput());
+            $successful = $result->successful();
+
+            $server->update([
+                'last_bootstrap_action' => $action,
+                'last_bootstrap_status' => $successful ? 'succeeded' : 'failed',
+                'last_bootstrap_output' => str($output !== '' ? $output : 'No output returned.')->limit(20000)->toString(),
+                'last_bootstrap_ran_at' => now(),
+            ]);
+            $this->broadcastClusterUpdated($server);
+
+            if (! $successful) {
+                return;
+            }
+
+            $capabilities = collect($server->capabilities ?? [])
+                ->push('coold')
+                ->when($server->builder_enabled, fn ($capabilities) => $capabilities->push('builder'))
+                ->unique()
+                ->values()
+                ->all();
+
+            $server->update([
+                'status' => 'installed',
+                'capabilities' => $capabilities,
+                'last_bootstrapped_at' => now(),
+            ]);
+            $this->broadcastClusterUpdated($server);
+
+            $this->writeBootstrapMarker($cluster, $server, $sshConfigLocation);
+        } catch (\Throwable $e) {
+            $this->markFailed($server, $action, $e->getMessage());
+        } finally {
+            $this->deleteDirectory($tempDirectory);
+        }
+    }
+
+    public function failed(?\Throwable $exception): void
+    {
+        $server = V5Server::query()->find($this->serverId);
+
+        if (! $server instanceof V5Server) {
+            return;
+        }
+
+        $this->markFailed($server, $server->last_bootstrap_action ?? 'bootstrap', $exception?->getMessage() ?? 'Bootstrap job failed.');
+
+        Log::warning('V5 server bootstrap job failed', [
+            'server_id' => $this->serverId,
+            'cluster_id' => $this->clusterId,
+            'exception' => $exception?->getMessage(),
+        ]);
+    }
+
+    private function markFailed(V5Server $server, string $action, string $output): void
+    {
+        $server->update([
+            'last_bootstrap_action' => $action,
+            'last_bootstrap_status' => 'failed',
+            'last_bootstrap_output' => str($output)->limit(20000)->toString(),
+            'last_bootstrap_ran_at' => now(),
+        ]);
+        $this->broadcastClusterUpdated($server);
+    }
+
+    private function broadcastClusterUpdated(V5Server $server): void
+    {
+        V5ClusterUpdated::dispatch($server->team_id, $server->cluster_id);
+    }
+
+    private function bootstrapCommand(V5Cluster $cluster, Collection $servers, V5Server $newServer, string $sshConfigLocation, string $action): array
+    {
+        $command = [
+            $this->coolifyCliBin(),
+            'init',
+            $action,
+            '--format',
+            'table',
+            '--nodes',
+            $servers->map(fn (V5Server $server) => $this->bootstrapNode($server))->implode(','),
+            '--ssh-config',
+            $sshConfigLocation,
+            '--namespaces',
+            implode(',', $cluster->namespaces ?? V5Cluster::DEFAULT_NAMESPACES),
+            '--container-pool',
+            $cluster->container_network_pool,
+            '--container-prefix',
+            (string) $cluster->container_network_prefix,
+            '--wg-mgmt-pool',
+            $cluster->wireguard_management_pool,
+            '--wg-interface',
+            $cluster->wireguard_interface,
+            '--wg-listen-port',
+            (string) $cluster->wireguard_listen_port,
+            '--coold-version',
+            $cluster->coold_version,
+            '--corrosion-version',
+            $cluster->corrosion_version,
+            '--corrosion-gossip-port',
+            (string) $cluster->corrosion_gossip_port,
+            '--corrosion-api-port',
+            (string) $cluster->corrosion_api_port,
+        ];
+
+        if ($action === 'extend') {
+            array_push($command, '--new-nodes', $this->bootstrapNode($newServer));
+        }
+
+        $listenOverrides = $this->wireguardListenPortOverrides($servers);
+        if ($listenOverrides !== '') {
+            array_push($command, '--wg-listen-port-overrides', $listenOverrides);
+        }
+
+        $endpointOverrides = $this->wireguardEndpointOverrides($servers);
+        if ($endpointOverrides !== '') {
+            array_push($command, '--wg-endpoint-overrides', $endpointOverrides);
+        }
+
+        if (! $cluster->default_deny_containers) {
+            $command[] = '--skip-default-deny';
+        }
+
+        $builderServers = $servers->filter(fn (V5Server $server) => $server->builder_enabled);
+        if ($cluster->builder_enabled && $builderServers->isNotEmpty()) {
+            array_push(
+                $command,
+                '--enable-builder',
+                '--builder-hosts',
+                $builderServers
+                    ->map(fn (V5Server $server) => $this->bootstrapNode($server))
+                    ->implode(','),
+                '--builder-capacity',
+                (string) $cluster->builder_capacity,
+                '--builder-cpu-quota',
+                $cluster->builder_cpu_quota,
+                '--builder-memory-max',
+                $cluster->builder_memory_max,
+                '--builder-timeout-secs',
+                (string) $cluster->builder_timeout_secs,
+            );
+        }
+
+        $command[] = '--yes';
+
+        return $command;
+    }
+
+    private function coolifyCliBin(): string
+    {
+        $configuredBinary = (string) config('coold.coolify_cli_bin', '/usr/local/bin/coolify');
+        $devBinary = base_path('.dev/bin/coolify');
+
+        if ($configuredBinary === '/usr/local/bin/coolify' && $this->isRunnableDevelopmentCliBinary($devBinary)) {
+            return $devBinary;
+        }
+
+        return $configuredBinary;
+    }
+
+    private function isRunnableDevelopmentCliBinary(string $binary): bool
+    {
+        if (! is_file($binary)) {
+            return false;
+        }
+
+        $header = file_get_contents($binary, false, null, 0, 4);
+
+        if ($header === false) {
+            return false;
+        }
+
+        if (str_starts_with($header, '#!')) {
+            return true;
+        }
+
+        if ($header === "\x7FELF") {
+            return true;
+        }
+
+        return false;
+    }
+
+    private function bootstrapNode(V5Server $server): string
+    {
+        return 'v5-server-'.($server->uuid ?: $server->id);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function detectExistingBootstrap(V5Server $server, string $sshConfigLocation): array
+    {
+        $result = Process::timeout(15)->run([
+            'ssh',
+            '-F',
+            $sshConfigLocation,
+            $this->bootstrapNode($server),
+            'if [ -f '.escapeshellarg(self::BOOTSTRAP_MARKER_PATH).' ]; then cat '.escapeshellarg(self::BOOTSTRAP_MARKER_PATH).'; fi',
+        ]);
+
+        if (! $result->successful()) {
+            return [];
+        }
+
+        $output = trim($result->output());
+
+        if ($output === '') {
+            return [];
+        }
+
+        try {
+            $decoded = json_decode($output, true, flags: JSON_THROW_ON_ERROR);
+        } catch (\JsonException) {
+            return [];
+        }
+
+        return is_array($decoded) ? $decoded : [];
+    }
+
+    /**
+     * @param  array<string, mixed>  $marker
+     */
+    private function adoptExistingBootstrap(V5Server $server, array $marker): void
+    {
+        $serverUuid = is_string($marker['server_uuid'] ?? null) ? $marker['server_uuid'] : null;
+        $updates = [
+            'wireguard_management_ip' => is_string($marker['wireguard_management_ip'] ?? null) ? $marker['wireguard_management_ip'] : $server->wireguard_management_ip,
+            'wireguard_public_key' => is_string($marker['wireguard_public_key'] ?? null) ? $marker['wireguard_public_key'] : $server->wireguard_public_key,
+            'container_subnets' => is_array($marker['container_subnets'] ?? null) ? $marker['container_subnets'] : $server->container_subnets,
+            'status' => 'installed',
+            'last_bootstrap_status' => 'succeeded',
+            'last_bootstrap_output' => 'Adopted existing Coolify bootstrap state for this cluster.',
+            'last_bootstrap_ran_at' => now(),
+            'last_bootstrapped_at' => now(),
+        ];
+
+        if ($serverUuid !== null && ! V5Server::query()->where('uuid', $serverUuid)->whereKeyNot($server->id)->exists()) {
+            $updates['uuid'] = $serverUuid;
+        }
+
+        $server->update($updates);
+        $this->broadcastClusterUpdated($server);
+    }
+
+    private function writeBootstrapMarker(V5Cluster $cluster, V5Server $server, string $sshConfigLocation): void
+    {
+        $payload = base64_encode(json_encode([
+            'cluster_id' => $cluster->id,
+            'server_uuid' => $server->uuid,
+            'wireguard_management_ip' => $server->wireguard_management_ip,
+            'wireguard_public_key' => $server->wireguard_public_key,
+            'container_subnets' => $server->container_subnets ?? [],
+        ], JSON_THROW_ON_ERROR));
+
+        Process::timeout(15)->run([
+            'ssh',
+            '-F',
+            $sshConfigLocation,
+            $this->bootstrapNode($server),
+            "payload='{$payload}'; if [ \"$(id -u)\" = \"0\" ]; then mkdir -p /etc/coolify && printf %s \"$payload\" | base64 -d > ".escapeshellarg(self::BOOTSTRAP_MARKER_PATH)."; else sudo mkdir -p /etc/coolify && printf %s \"$payload\" | base64 -d | sudo tee ".escapeshellarg(self::BOOTSTRAP_MARKER_PATH).' >/dev/null; fi',
+        ]);
+    }
+
+    /**
+     * @param  Collection<int, V5Server>  $servers
+     */
+    private function writeBootstrapSshConfig(Collection $servers, string $tempDirectory): string
+    {
+        $config = '';
+
+        $servers->each(function (V5Server $server) use (&$config, $tempDirectory): void {
+            $keyLocation = "{$tempDirectory}/server-{$server->id}.key";
+            file_put_contents($keyLocation, $server->privateKey->private_key);
+            chmod($keyLocation, 0600);
+
+            $config .= implode("\n", [
+                'Host '.$this->bootstrapNode($server),
+                '  HostName '.$server->host,
+                '  Port '.$server->ssh_port,
+                '  User '.$server->ssh_user,
+                '  IdentityFile '.$keyLocation,
+                '  IdentitiesOnly yes',
+                '  LogLevel ERROR',
+                '  StrictHostKeyChecking no',
+                '  UserKnownHostsFile /dev/null',
+                '  BatchMode yes',
+                '',
+            ]);
+        });
+
+        $sshConfigLocation = "{$tempDirectory}/ssh.config";
+        file_put_contents($sshConfigLocation, $config);
+        chmod($sshConfigLocation, 0600);
+
+        return $sshConfigLocation;
+    }
+
+    private function deleteDirectory(string $directory): void
+    {
+        if (! is_dir($directory)) {
+            return;
+        }
+
+        foreach (scandir($directory) ?: [] as $file) {
+            if ($file === '.' || $file === '..') {
+                continue;
+            }
+
+            $path = "{$directory}/{$file}";
+
+            if (is_dir($path)) {
+                $this->deleteDirectory($path);
+
+                continue;
+            }
+
+            @unlink($path);
+        }
+
+        @rmdir($directory);
+    }
+
+    /**
+     * @param  Collection<int, V5Server>  $servers
+     */
+    private function wireguardListenPortOverrides(Collection $servers): string
+    {
+        return $servers
+            ->filter(fn (V5Server $server) => $server->wireguard_listen_port_override !== null)
+            ->map(fn (V5Server $server) => $this->bootstrapNode($server).'='.$server->wireguard_listen_port_override)
+            ->implode(',');
+    }
+
+    /**
+     * @param  Collection<int, V5Server>  $servers
+     */
+    private function wireguardEndpointOverrides(Collection $servers): string
+    {
+        return $servers
+            ->filter(fn (V5Server $server) => $server->wireguard_endpoint_override !== null)
+            ->map(fn (V5Server $server) => $this->bootstrapNode($server).'='.$server->wireguard_endpoint_override)
+            ->implode(',');
+    }
+}

app/Models/V5/Server.php

@@ -12,6 +12,7 @@ class Server extends V5Model
     protected $table = 'v5_servers';
 
     protected $fillable = [
+        'uuid',
         'team_id',
         'cluster_id',
         'created_by_user_id',
@@ -32,6 +33,10 @@ class Server extends V5Model
         'wireguard_public_key',
         'container_subnets',
         'last_bootstrapped_at',
+        'last_bootstrap_action',
+        'last_bootstrap_status',
+        'last_bootstrap_output',
+        'last_bootstrap_ran_at',
         'last_status_check',
         'last_status_output',
         'last_status_checked_at',
@@ -44,6 +49,7 @@ class Server extends V5Model
             'builder_enabled' => 'boolean',
             'container_subnets' => 'array',
             'last_bootstrapped_at' => 'datetime',
+            'last_bootstrap_ran_at' => 'datetime',
             'last_status_checked_at' => 'datetime',
         ];
     }

app/Models/V5/V5Model.php

@@ -3,8 +3,21 @@
 namespace App\Models\V5;
 
 use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Facades\Schema;
 
 abstract class V5Model extends Model
 {
-    //
+    protected static function boot(): void
+    {
+        parent::boot();
+
+        static::creating(function (Model $model): void {
+            if (
+                Schema::hasColumn($model->getTable(), 'uuid')
+                && ! $model->getAttribute('uuid')
+            ) {
+                $model->setAttribute('uuid', new_public_id());
+            }
+        });
+    }
 }