Merge branch 'next' into fix/improved-responses-on-git-error

app/Actions/Application/GenerateConfig.php

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

app/Actions/Application/IsHorizonQueueEmpty.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Actions\Application;
+
+use Laravel\Horizon\Contracts\JobRepository;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class IsHorizonQueueEmpty
+{
+    use AsAction;
+
+    public function handle()
+    {
+        $hostname = gethostname();
+        $recent = app(JobRepository::class)->getRecent();
+        if ($recent) {
+            $running = $recent->filter(function ($job) use ($hostname) {
+                $payload = json_decode($job->payload);
+                $tags = data_get($payload, 'tags');
+
+                return $job->status != 'completed' &&
+                       $job->status != 'failed' &&
+                       isset($tags) &&
+                       is_array($tags) &&
+                       in_array('server:'.$hostname, $tags);
+            });
+            if ($running->count() > 0) {
+                echo 'false';
+
+                return false;
+            }
+        }
+        echo 'true';
+
+        return true;
+    }
+}

app/Actions/Application/LoadComposeFile.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Actions\Application;
+
+use App\Models\Application;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class LoadComposeFile
+{
+    use AsAction;
+
+    public function handle(Application $application)
+    {
+        $application->loadComposeFile();
+    }
+}

app/Actions/Application/StopApplication.php

@@ -2,6 +2,7 @@
 
 namespace App\Actions\Application;
 
+use App\Actions\Server\CleanupDocker;
 use App\Models\Application;
 use Lorisleiva\Actions\Concerns\AsAction;
 
@@ -9,35 +10,32 @@ class StopApplication
 {
     use AsAction;
 
-    public function handle(Application $application)
+    public function handle(Application $application, bool $previewDeployments = false, bool $dockerCleanup = true)
     {
-        if ($application->destination->server->isSwarm()) {
-            instant_remote_process(["docker stack rm {$application->uuid}"], $application->destination->server);
-
-            return;
-        }
-
-        $servers = collect([]);
-        $servers->push($application->destination->server);
-        $application->additional_servers->map(function ($server) use ($servers) {
-            $servers->push($server);
-        });
-        foreach ($servers as $server) {
+        try {
+            $server = $application->destination->server;
             if (! $server->isFunctional()) {
                 return 'Server is not functional';
             }
-            $containers = getCurrentApplicationContainerStatus($server, $application->id, 0);
-            if ($containers->count() > 0) {
-                foreach ($containers as $container) {
-                    $containerName = data_get($container, 'Names');
-                    if ($containerName) {
-                        instant_remote_process(
-                            ["docker rm -f {$containerName}"],
-                            $server
-                        );
-                    }
-                }
+
+            if ($server->isSwarm()) {
+                instant_remote_process(["docker stack rm {$application->uuid}"], $server);
+
+                return;
             }
+
+            $containersToStop = $application->getContainersToStop($previewDeployments);
+            $application->stopContainers($containersToStop, $server);
+
+            if ($application->build_pack === 'dockercompose') {
+                $application->delete_connected_networks($application->uuid);
+            }
+
+            if ($dockerCleanup) {
+                CleanupDocker::dispatch($server, true);
+            }
+        } catch (\Exception $e) {
+            return $e->getMessage();
         }
     }
 }

app/Actions/Application/StopApplicationOneServer.php

@@ -32,8 +32,6 @@ class StopApplicationOneServer
                 }
             }
         } catch (\Exception $e) {
-            ray($e->getMessage());
-
             return $e->getMessage();
         }
     }

app/Actions/CoolifyTask/PrepareCoolifyTask.php

@@ -3,6 +3,7 @@
 namespace App\Actions\CoolifyTask;
 
 use App\Data\CoolifyTaskArgs;
+use App\Enums\ActivityTypes;
 use App\Jobs\CoolifyTask;
 use Spatie\Activitylog\Models\Activity;
 
@@ -40,8 +41,17 @@ class PrepareCoolifyTask
 
     public function __invoke(): Activity
     {
-        $job = new CoolifyTask($this->activity, ignore_errors: $this->remoteProcessArgs->ignore_errors, call_event_on_finish: $this->remoteProcessArgs->call_event_on_finish, call_event_data: $this->remoteProcessArgs->call_event_data);
-        dispatch($job);
+        $job = new CoolifyTask(
+            activity: $this->activity,
+            ignore_errors: $this->remoteProcessArgs->ignore_errors,
+            call_event_on_finish: $this->remoteProcessArgs->call_event_on_finish,
+            call_event_data: $this->remoteProcessArgs->call_event_data,
+        );
+        if ($this->remoteProcessArgs->type === ActivityTypes::COMMAND->value) {
+            dispatch($job)->onQueue('high');
+        } else {
+            dispatch($job);
+        }
         $this->activity->refresh();
 
         return $this->activity;

app/Actions/CoolifyTask/RunRemoteProcess.php

@@ -4,10 +4,12 @@ namespace App\Actions\CoolifyTask;
 
 use App\Enums\ActivityTypes;
 use App\Enums\ProcessStatus;
+use App\Helpers\SshMultiplexingHelper;
 use App\Jobs\ApplicationDeploymentJob;
 use App\Models\Server;
 use Illuminate\Process\ProcessResult;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Facades\Process;
 use Spatie\Activitylog\Models\Activity;
 
@@ -38,8 +40,7 @@ class RunRemoteProcess
      */
     public function __construct(Activity $activity, bool $hide_from_output = false, bool $ignore_errors = false, $call_event_on_finish = null, $call_event_data = null)
     {
-
-        if ($activity->getExtraProperty('type') !== ActivityTypes::INLINE->value) {
+        if ($activity->getExtraProperty('type') !== ActivityTypes::INLINE->value && $activity->getExtraProperty('type') !== ActivityTypes::COMMAND->value) {
             throw new \RuntimeException('Incompatible Activity to run a remote command.');
         }
 
@@ -124,7 +125,7 @@ class RunRemoteProcess
                     ]));
                 }
             } catch (\Throwable $e) {
-                ray($e);
+                Log::error('Error calling event: '.$e->getMessage());
             }
         }
 
@@ -137,7 +138,7 @@ class RunRemoteProcess
         $command = $this->activity->getExtraProperty('command');
         $server = Server::whereUuid($server_uuid)->firstOrFail();
 
-        return generateSshCommand($server, $command);
+        return SshMultiplexingHelper::generateSshCommand($server, $command);
     }
 
     protected function handleOutput(string $type, string $output)

app/Actions/Database/RestartDatabase.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Actions\Database;
+
+use App\Models\StandaloneClickhouse;
+use App\Models\StandaloneDragonfly;
+use App\Models\StandaloneKeydb;
+use App\Models\StandaloneMariadb;
+use App\Models\StandaloneMongodb;
+use App\Models\StandaloneMysql;
+use App\Models\StandalonePostgresql;
+use App\Models\StandaloneRedis;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class RestartDatabase
+{
+    use AsAction;
+
+    public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database)
+    {
+        $server = $database->destination->server;
+        if (! $server->isFunctional()) {
+            return 'Server is not functional';
+        }
+        StopDatabase::run($database);
+
+        return StartDatabase::run($database);
+    }
+}

app/Actions/Database/StartClickhouse.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneClickhouse;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -52,6 +51,8 @@ class StartClickhouse
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => "clickhouse-client --password {$this->database->clickhouse_admin_password} --query 'SELECT 1'",
@@ -80,14 +81,7 @@ class StartClickhouse
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => 'tcp://127.0.0.1:24224',
-                    'fluentd-async' => 'true',
-                    'fluentd-sub-second-precision' => 'true',
-                ],
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -103,6 +97,11 @@ class StartClickhouse
         if (count($volume_names) > 0) {
             $docker_compose['volumes'] = $volume_names;
         }
+
+        // Add custom docker run options
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);
         $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
@@ -155,14 +154,16 @@ class StartClickhouse
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('CLICKHOUSE_ADMIN_USER'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('CLICKHOUSE_ADMIN_USER'))->isEmpty()) {
             $environment_variables->push("CLICKHOUSE_ADMIN_USER={$this->database->clickhouse_admin_user}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('CLICKHOUSE_ADMIN_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('CLICKHOUSE_ADMIN_PASSWORD'))->isEmpty()) {
             $environment_variables->push("CLICKHOUSE_ADMIN_PASSWORD={$this->database->clickhouse_admin_password}");
         }
 
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
 }

app/Actions/Database/StartDatabase.php

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

app/Actions/Database/StartDatabaseProxy.php

@@ -26,7 +26,7 @@ class StartDatabaseProxy
         $server = data_get($database, 'destination.server');
         $containerName = data_get($database, 'uuid');
         $proxyContainerName = "{$database->uuid}-proxy";
-        if ($database->getMorphClass() === 'App\Models\ServiceDatabase') {
+        if ($database->getMorphClass() === \App\Models\ServiceDatabase::class) {
             $databaseType = $database->databaseType();
             // $connectPredefined = data_get($database, 'service.connect_to_docker_network');
             $network = $database->service->uuid;
@@ -34,54 +34,54 @@ class StartDatabaseProxy
             $proxyContainerName = "{$database->service->uuid}-proxy";
             switch ($databaseType) {
                 case 'standalone-mariadb':
-                    $type = 'App\Models\StandaloneMariadb';
+                    $type = \App\Models\StandaloneMariadb::class;
                     $containerName = "mariadb-{$database->service->uuid}";
                     break;
                 case 'standalone-mongodb':
-                    $type = 'App\Models\StandaloneMongodb';
+                    $type = \App\Models\StandaloneMongodb::class;
                     $containerName = "mongodb-{$database->service->uuid}";
                     break;
                 case 'standalone-mysql':
-                    $type = 'App\Models\StandaloneMysql';
+                    $type = \App\Models\StandaloneMysql::class;
                     $containerName = "mysql-{$database->service->uuid}";
                     break;
                 case 'standalone-postgresql':
-                    $type = 'App\Models\StandalonePostgresql';
+                    $type = \App\Models\StandalonePostgresql::class;
                     $containerName = "postgresql-{$database->service->uuid}";
                     break;
                 case 'standalone-redis':
-                    $type = 'App\Models\StandaloneRedis';
+                    $type = \App\Models\StandaloneRedis::class;
                     $containerName = "redis-{$database->service->uuid}";
                     break;
                 case 'standalone-keydb':
-                    $type = 'App\Models\StandaloneKeydb';
+                    $type = \App\Models\StandaloneKeydb::class;
                     $containerName = "keydb-{$database->service->uuid}";
                     break;
                 case 'standalone-dragonfly':
-                    $type = 'App\Models\StandaloneDragonfly';
+                    $type = \App\Models\StandaloneDragonfly::class;
                     $containerName = "dragonfly-{$database->service->uuid}";
                     break;
                 case 'standalone-clickhouse':
-                    $type = 'App\Models\StandaloneClickhouse';
+                    $type = \App\Models\StandaloneClickhouse::class;
                     $containerName = "clickhouse-{$database->service->uuid}";
                     break;
             }
         }
-        if ($type === 'App\Models\StandaloneRedis') {
+        if ($type === \App\Models\StandaloneRedis::class) {
             $internalPort = 6379;
-        } elseif ($type === 'App\Models\StandalonePostgresql') {
+        } elseif ($type === \App\Models\StandalonePostgresql::class) {
             $internalPort = 5432;
-        } elseif ($type === 'App\Models\StandaloneMongodb') {
+        } elseif ($type === \App\Models\StandaloneMongodb::class) {
             $internalPort = 27017;
-        } elseif ($type === 'App\Models\StandaloneMysql') {
+        } elseif ($type === \App\Models\StandaloneMysql::class) {
             $internalPort = 3306;
-        } elseif ($type === 'App\Models\StandaloneMariadb') {
+        } elseif ($type === \App\Models\StandaloneMariadb::class) {
             $internalPort = 3306;
-        } elseif ($type === 'App\Models\StandaloneKeydb') {
+        } elseif ($type === \App\Models\StandaloneKeydb::class) {
             $internalPort = 6379;
-        } elseif ($type === 'App\Models\StandaloneDragonfly') {
+        } elseif ($type === \App\Models\StandaloneDragonfly::class) {
             $internalPort = 6379;
-        } elseif ($type === 'App\Models\StandaloneClickhouse') {
+        } elseif ($type === \App\Models\StandaloneClickhouse::class) {
             $internalPort = 9000;
         }
         $configuration_dir = database_proxy_dir($database->uuid);

app/Actions/Database/StartDragonfly.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneDragonfly;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -47,11 +46,10 @@ class StartDragonfly
                     'networks' => [
                         $this->database->destination->network,
                     ],
-                    'ulimits' => [
-                        'memlock' => '-1',
-                    ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => "redis-cli -a {$this->database->dragonfly_password} ping",
@@ -80,14 +78,7 @@ class StartDragonfly
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => 'tcp://127.0.0.1:24224',
-                    'fluentd-async' => 'true',
-                    'fluentd-sub-second-precision' => 'true',
-                ],
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -103,6 +94,11 @@ class StartDragonfly
         if (count($volume_names) > 0) {
             $docker_compose['volumes'] = $volume_names;
         }
+
+        // Add custom docker run options
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);
         $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
@@ -155,7 +151,7 @@ class StartDragonfly
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
             $environment_variables->push("REDIS_PASSWORD={$this->database->dragonfly_password}");
         }
 

app/Actions/Database/StartKeydb.php

@@ -4,7 +4,6 @@ namespace App\Actions\Database;
 
 use App\Models\StandaloneKeydb;
 use Illuminate\Support\Facades\Storage;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -51,6 +50,8 @@ class StartKeydb
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => "keydb-cli --pass {$this->database->keydb_password} ping",
@@ -79,14 +80,7 @@ class StartKeydb
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => 'tcp://127.0.0.1:24224',
-                    'fluentd-async' => 'true',
-                    'fluentd-sub-second-precision' => 'true',
-                ],
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -111,6 +105,10 @@ class StartKeydb
             ];
             $docker_compose['services'][$container_name]['command'] = "keydb-server /etc/keydb/keydb.conf --requirepass {$this->database->keydb_password} --appendonly yes";
         }
+
+        // Add custom docker run options
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);
         $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
@@ -163,10 +161,12 @@ class StartKeydb
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
             $environment_variables->push("REDIS_PASSWORD={$this->database->keydb_password}");
         }
 
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
 

app/Actions/Database/StartMariadb.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneMariadb;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -46,6 +45,8 @@ class StartMariadb
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => ['CMD', 'healthcheck.sh', '--connect', '--innodb_initialized'],
@@ -74,14 +75,7 @@ class StartMariadb
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => 'tcp://127.0.0.1:24224',
-                    'fluentd-async' => 'true',
-                    'fluentd-sub-second-precision' => 'true',
-                ],
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -105,6 +99,11 @@ class StartMariadb
                 'read_only' => true,
             ];
         }
+
+        // Add custom docker run options
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);
         $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
@@ -157,21 +156,23 @@ class StartMariadb
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MARIADB_ROOT_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MARIADB_ROOT_PASSWORD'))->isEmpty()) {
             $environment_variables->push("MARIADB_ROOT_PASSWORD={$this->database->mariadb_root_password}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MARIADB_DATABASE'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MARIADB_DATABASE'))->isEmpty()) {
             $environment_variables->push("MARIADB_DATABASE={$this->database->mariadb_database}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MARIADB_USER'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MARIADB_USER'))->isEmpty()) {
             $environment_variables->push("MARIADB_USER={$this->database->mariadb_user}");
         }
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MARIADB_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MARIADB_PASSWORD'))->isEmpty()) {
             $environment_variables->push("MARIADB_PASSWORD={$this->database->mariadb_password}");
         }
 
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
 

app/Actions/Database/StartMongodb.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneMongodb;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -26,6 +25,10 @@ class StartMongodb
         $container_name = $this->database->uuid;
         $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
+        if (isDev()) {
+            $this->configuration_dir = '/var/lib/docker/volumes/coolify_dev_coolify_data/_data/databases/'.$container_name;
+        }
+
         $this->commands = [
             "echo 'Starting {$database->name}.'",
             "mkdir -p $this->configuration_dir",
@@ -50,6 +53,8 @@ class StartMongodb
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => [
@@ -82,14 +87,7 @@ class StartMongodb
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => 'tcp://127.0.0.1:24224',
-                    'fluentd-async' => 'true',
-                    'fluentd-sub-second-precision' => 'true',
-                ],
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -122,6 +120,10 @@ class StartMongodb
             'read_only' => true,
         ];
 
+        // Add custom docker run options
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);
         $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
@@ -174,18 +176,20 @@ class StartMongodb
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MONGO_INITDB_ROOT_USERNAME'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MONGO_INITDB_ROOT_USERNAME'))->isEmpty()) {
             $environment_variables->push("MONGO_INITDB_ROOT_USERNAME={$this->database->mongo_initdb_root_username}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MONGO_INITDB_ROOT_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MONGO_INITDB_ROOT_PASSWORD'))->isEmpty()) {
             $environment_variables->push("MONGO_INITDB_ROOT_PASSWORD={$this->database->mongo_initdb_root_password}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MONGO_INITDB_DATABASE'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MONGO_INITDB_DATABASE'))->isEmpty()) {
             $environment_variables->push("MONGO_INITDB_DATABASE={$this->database->mongo_initdb_database}");
         }
 
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
 

app/Actions/Database/StartMysql.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandaloneMysql;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -46,6 +45,8 @@ class StartMysql
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => ['CMD', 'mysqladmin', 'ping', '-h', 'localhost', '-u', 'root', "-p{$this->database->mysql_root_password}"],
@@ -74,14 +75,7 @@ class StartMysql
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => 'tcp://127.0.0.1:24224',
-                    'fluentd-async' => 'true',
-                    'fluentd-sub-second-precision' => 'true',
-                ],
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -105,6 +99,11 @@ class StartMysql
                 'read_only' => true,
             ];
         }
+
+        // Add custom docker run options
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);
         $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
@@ -157,21 +156,23 @@ class StartMysql
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MYSQL_ROOT_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MYSQL_ROOT_PASSWORD'))->isEmpty()) {
             $environment_variables->push("MYSQL_ROOT_PASSWORD={$this->database->mysql_root_password}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MYSQL_DATABASE'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MYSQL_DATABASE'))->isEmpty()) {
             $environment_variables->push("MYSQL_DATABASE={$this->database->mysql_database}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MYSQL_USER'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MYSQL_USER'))->isEmpty()) {
             $environment_variables->push("MYSQL_USER={$this->database->mysql_user}");
         }
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('MYSQL_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('MYSQL_PASSWORD'))->isEmpty()) {
             $environment_variables->push("MYSQL_PASSWORD={$this->database->mysql_password}");
         }
 
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
 

app/Actions/Database/StartPostgresql.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Database;
 
 use App\Models\StandalonePostgresql;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -50,6 +49,8 @@ class StartPostgresql
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => [
@@ -81,14 +82,7 @@ class StartPostgresql
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => 'tcp://127.0.0.1:24224',
-                    'fluentd-async' => 'true',
-                    'fluentd-sub-second-precision' => 'true',
-                ],
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -127,6 +121,10 @@ class StartPostgresql
                 'config_file=/etc/postgresql/postgresql.conf',
             ];
         }
+        // Add custom docker run options
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);
         $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
@@ -179,21 +177,23 @@ class StartPostgresql
             $environment_variables->push("$env->key=$env->real_value");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('POSTGRES_USER'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('POSTGRES_USER'))->isEmpty()) {
             $environment_variables->push("POSTGRES_USER={$this->database->postgres_user}");
         }
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('PGUSER'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('PGUSER'))->isEmpty()) {
             $environment_variables->push("PGUSER={$this->database->postgres_user}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('POSTGRES_PASSWORD'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('POSTGRES_PASSWORD'))->isEmpty()) {
             $environment_variables->push("POSTGRES_PASSWORD={$this->database->postgres_password}");
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('POSTGRES_DB'))->isEmpty()) {
+        if ($environment_variables->filter(fn ($env) => str($env)->contains('POSTGRES_DB'))->isEmpty()) {
             $environment_variables->push("POSTGRES_DB={$this->database->postgres_db}");
         }
 
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
+
         return $environment_variables->all();
     }
 

app/Actions/Database/StartRedis.php

@@ -4,7 +4,6 @@ namespace App\Actions\Database;
 
 use App\Models\StandaloneRedis;
 use Illuminate\Support\Facades\Storage;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
 
@@ -22,8 +21,6 @@ class StartRedis
     {
         $this->database = $database;
 
-        $startCommand = "redis-server --requirepass {$this->database->redis_password} --appendonly yes";
-
         $container_name = $this->database->uuid;
         $this->configuration_dir = database_configuration_dir().'/'.$container_name;
 
@@ -38,6 +35,8 @@ class StartRedis
         $environment_variables = $this->generate_environment_variables();
         $this->add_custom_redis();
 
+        $startCommand = $this->buildStartCommand();
+
         $docker_compose = [
             'services' => [
                 $container_name => [
@@ -51,6 +50,8 @@ class StartRedis
                     ],
                     'labels' => [
                         'coolify.managed' => 'true',
+                        'coolify.type' => 'database',
+                        'coolify.databaseId' => $this->database->id,
                     ],
                     'healthcheck' => [
                         'test' => [
@@ -83,14 +84,7 @@ class StartRedis
             data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
         }
         if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
-            $docker_compose['services'][$container_name]['logging'] = [
-                'driver' => 'fluentd',
-                'options' => [
-                    'fluentd-address' => 'tcp://127.0.0.1:24224',
-                    'fluentd-async' => 'true',
-                    'fluentd-sub-second-precision' => 'true',
-                ],
-            ];
+            $docker_compose['services'][$container_name]['logging'] = generate_fluentd_configuration();
         }
         if (count($this->database->ports_mappings_array) > 0) {
             $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
@@ -113,8 +107,12 @@ class StartRedis
                 'target' => '/usr/local/etc/redis/redis.conf',
                 'read_only' => true,
             ];
-            $docker_compose['services'][$container_name]['command'] = "redis-server /usr/local/etc/redis/redis.conf --requirepass {$this->database->redis_password} --appendonly yes";
         }
+
+        // Add custom docker run options
+        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
+        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);
+
         $docker_compose = Yaml::dump($docker_compose, 10);
         $docker_compose_base64 = base64_encode($docker_compose);
         $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
@@ -163,17 +161,54 @@ class StartRedis
     private function generate_environment_variables()
     {
         $environment_variables = collect();
+
         foreach ($this->database->runtime_environment_variables as $env) {
-            $environment_variables->push("$env->key=$env->real_value");
+            if ($env->is_shared) {
+                $environment_variables->push("$env->key=$env->real_value");
+
+                if ($env->key === 'REDIS_PASSWORD') {
+                    $this->database->update(['redis_password' => $env->real_value]);
+                }
+
+                if ($env->key === 'REDIS_USERNAME') {
+                    $this->database->update(['redis_username' => $env->real_value]);
+                }
+            } else {
+                if ($env->key === 'REDIS_PASSWORD') {
+                    $env->update(['value' => $this->database->redis_password]);
+                } elseif ($env->key === 'REDIS_USERNAME') {
+                    $env->update(['value' => $this->database->redis_username]);
+                }
+                $environment_variables->push("$env->key=$env->real_value");
+            }
         }
 
-        if ($environment_variables->filter(fn ($env) => Str::of($env)->contains('REDIS_PASSWORD'))->isEmpty()) {
-            $environment_variables->push("REDIS_PASSWORD={$this->database->redis_password}");
-        }
+        add_coolify_default_environment_variables($this->database, $environment_variables, $environment_variables);
 
         return $environment_variables->all();
     }
 
+    private function buildStartCommand(): string
+    {
+        $hasRedisConf = ! is_null($this->database->redis_conf) && ! empty($this->database->redis_conf);
+        $redisConfPath = '/usr/local/etc/redis/redis.conf';
+
+        if ($hasRedisConf) {
+            $confContent = $this->database->redis_conf;
+            $hasRequirePass = str_contains($confContent, 'requirepass');
+
+            if ($hasRequirePass) {
+                $command = "redis-server $redisConfPath";
+            } else {
+                $command = "redis-server $redisConfPath --requirepass {$this->database->redis_password}";
+            }
+        } else {
+            $command = "redis-server --requirepass {$this->database->redis_password} --appendonly yes";
+        }
+
+        return $command;
+    }
+
     private function add_custom_redis()
     {
         if (is_null($this->database->redis_conf) || empty($this->database->redis_conf)) {

app/Actions/Database/StopDatabase.php

@@ -2,6 +2,7 @@
 
 namespace App\Actions\Database;
 
+use App\Actions\Server\CleanupDocker;
 use App\Models\StandaloneClickhouse;
 use App\Models\StandaloneDragonfly;
 use App\Models\StandaloneKeydb;
@@ -10,26 +11,65 @@ use App\Models\StandaloneMongodb;
 use App\Models\StandaloneMysql;
 use App\Models\StandalonePostgresql;
 use App\Models\StandaloneRedis;
+use Illuminate\Support\Facades\Process;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class StopDatabase
 {
     use AsAction;
 
-    public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database)
+    public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database, bool $isDeleteOperation = false, bool $dockerCleanup = true)
     {
         $server = $database->destination->server;
         if (! $server->isFunctional()) {
             return 'Server is not functional';
         }
-        instant_remote_process(
-            ["docker rm -f {$database->uuid}"],
-            $server
-        );
+
+        $this->stopContainer($database, $database->uuid, 300);
+        if (! $isDeleteOperation) {
+            if ($dockerCleanup) {
+                CleanupDocker::dispatch($server, true);
+            }
+        }
+
         if ($database->is_public) {
             StopDatabaseProxy::run($database);
         }
-        // TODO: make notification for services
-        // $database->environment->project->team->notify(new StatusChanged($database));
+
+        return 'Database stopped successfully';
+    }
+
+    private function stopContainer($database, string $containerName, int $timeout = 300): void
+    {
+        $server = $database->destination->server;
+
+        $process = Process::timeout($timeout)->start("docker stop --time=$timeout $containerName");
+
+        $startTime = time();
+        while ($process->running()) {
+            if (time() - $startTime >= $timeout) {
+                $this->forceStopContainer($containerName, $server);
+                break;
+            }
+            usleep(100000);
+        }
+
+        $this->removeContainer($containerName, $server);
+    }
+
+    private function forceStopContainer(string $containerName, $server): void
+    {
+        instant_remote_process(command: ["docker kill $containerName"], server: $server, throwError: false);
+    }
+
+    private function removeContainer(string $containerName, $server): void
+    {
+        instant_remote_process(command: ["docker rm -f $containerName"], server: $server, throwError: false);
+    }
+
+    private function deleteConnectedNetworks($uuid, $server)
+    {
+        instant_remote_process(["docker network disconnect {$uuid} coolify-proxy"], $server, false);
+        instant_remote_process(["docker network rm {$uuid}"], $server, false);
     }
 }

app/Actions/Database/StopDatabaseProxy.php

@@ -2,6 +2,7 @@
 
 namespace App\Actions\Database;
 
+use App\Events\DatabaseProxyStopped;
 use App\Models\ServiceDatabase;
 use App\Models\StandaloneClickhouse;
 use App\Models\StandaloneDragonfly;
@@ -21,12 +22,16 @@ class StopDatabaseProxy
     {
         $server = data_get($database, 'destination.server');
         $uuid = $database->uuid;
-        if ($database->getMorphClass() === 'App\Models\ServiceDatabase') {
+        if ($database->getMorphClass() === \App\Models\ServiceDatabase::class) {
             $uuid = $database->service->uuid;
             $server = data_get($database, 'service.server');
         }
         instant_remote_process(["docker rm -f {$uuid}-proxy"], $server);
+
         $database->is_public = false;
         $database->save();
+
+        DatabaseProxyStopped::dispatch();
+
     }
 }

app/Actions/Docker/GetContainersStatus.php

@@ -3,15 +3,13 @@
 namespace App\Actions\Docker;
 
 use App\Actions\Database\StartDatabaseProxy;
-use App\Actions\Proxy\CheckProxy;
-use App\Actions\Proxy\StartProxy;
 use App\Actions\Shared\ComplexStatusCheck;
 use App\Models\ApplicationPreview;
 use App\Models\Server;
 use App\Models\ServiceDatabase;
 use App\Notifications\Container\ContainerRestarted;
-use App\Notifications\Container\ContainerStopped;
 use Illuminate\Support\Arr;
+use Illuminate\Support\Collection;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class GetContainersStatus
@@ -20,16 +18,19 @@ class GetContainersStatus
 
     public $applications;
 
+    public ?Collection $containers;
+
+    public ?Collection $containerReplicates;
+
     public $server;
 
-    public function handle(Server $server)
+    public function handle(Server $server, ?Collection $containers = null, ?Collection $containerReplicates = null)
     {
-        // if (isDev()) {
-        //     $server = Server::find(0);
-        // }
+        $this->containers = $containers;
+        $this->containerReplicates = $containerReplicates;
         $this->server = $server;
         if (! $this->server->isFunctional()) {
-            return 'Server is not ready.';
+            return 'Server is not functional.';
         }
         $this->applications = $this->server->applications();
         $skip_these_applications = collect([]);
@@ -45,343 +46,18 @@ class GetContainersStatus
         $this->applications = $this->applications->filter(function ($value, $key) use ($skip_these_applications) {
             return ! $skip_these_applications->pluck('id')->contains($value->id);
         });
-        $this->old_way();
-        // if ($this->server->isSwarm()) {
-        //     $this->old_way();
-        // } else {
-        //     if (!$this->server->is_metrics_enabled) {
-        //         $this->old_way();
-        //         return;
-        //     }
-        //     $sentinel_found = instant_remote_process(["docker inspect coolify-sentinel"], $this->server, false);
-        //     $sentinel_found = json_decode($sentinel_found, true);
-        //     $status = data_get($sentinel_found, '0.State.Status', 'exited');
-        //     if ($status === 'running') {
-        //         ray('Checking with Sentinel');
-        //         $this->sentinel();
-        //     } else {
-        //         ray('Checking the Old way');
-        //         $this->old_way();
-        //     }
-        // }
-    }
-
-    private function sentinel()
-    {
-        try {
-            $containers = $this->server->getContainers();
-            if ($containers->count() === 0) {
-                return;
-            }
-            $databases = $this->server->databases();
-            $services = $this->server->services()->get();
-            $previews = $this->server->previews();
-            $foundApplications = [];
-            $foundApplicationPreviews = [];
-            $foundDatabases = [];
-            $foundServices = [];
-
-            foreach ($containers as $container) {
-                $labels = Arr::undot(data_get($container, 'labels'));
-                $containerStatus = data_get($container, 'state');
-                $containerHealth = data_get($container, 'health_status', 'unhealthy');
-                $containerStatus = "$containerStatus ($containerHealth)";
-                $applicationId = data_get($labels, 'coolify.applicationId');
-                if ($applicationId) {
-                    $pullRequestId = data_get($labels, 'coolify.pullRequestId');
-                    if ($pullRequestId) {
-                        if (str($applicationId)->contains('-')) {
-                            $applicationId = str($applicationId)->before('-');
-                        }
-                        $preview = ApplicationPreview::where('application_id', $applicationId)->where('pull_request_id', $pullRequestId)->first();
-                        if ($preview) {
-                            $foundApplicationPreviews[] = $preview->id;
-                            $statusFromDb = $preview->status;
-                            if ($statusFromDb !== $containerStatus) {
-                                $preview->update(['status' => $containerStatus]);
-                            }
-                        } else {
-                            //Notify user that this container should not be there.
-                        }
-                    } else {
-                        $application = $this->applications->where('id', $applicationId)->first();
-                        if ($application) {
-                            $foundApplications[] = $application->id;
-                            $statusFromDb = $application->status;
-                            if ($statusFromDb !== $containerStatus) {
-                                $application->update(['status' => $containerStatus]);
-                            }
-                        } else {
-                            //Notify user that this container should not be there.
-                        }
-                    }
-                } else {
-                    $uuid = data_get($labels, 'com.docker.compose.service');
-                    $type = data_get($labels, 'coolify.type');
-                    if ($uuid) {
-                        if ($type === 'service') {
-                            $database_id = data_get($labels, 'coolify.service.subId');
-                            if ($database_id) {
-                                $service_db = ServiceDatabase::where('id', $database_id)->first();
-                                if ($service_db) {
-                                    $uuid = $service_db->service->uuid;
-                                    $isPublic = data_get($service_db, 'is_public');
-                                    if ($isPublic) {
-                                        $foundTcpProxy = $containers->filter(function ($value, $key) use ($uuid) {
-                                            if ($this->server->isSwarm()) {
-                                                // TODO: fix this with sentinel
-                                                return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
-                                            } else {
-                                                return data_get($value, 'name') === "$uuid-proxy";
-                                            }
-                                        })->first();
-                                        if (! $foundTcpProxy) {
-                                            StartDatabaseProxy::run($service_db);
-                                            // $this->server->team?->notify(new ContainerRestarted("TCP Proxy for {$service_db->service->name}", $this->server));
-                                        }
-                                    }
-                                }
-                            }
-                        } else {
-                            $database = $databases->where('uuid', $uuid)->first();
-                            if ($database) {
-                                $isPublic = data_get($database, 'is_public');
-                                $foundDatabases[] = $database->id;
-                                $statusFromDb = $database->status;
-                                if ($statusFromDb !== $containerStatus) {
-                                    $database->update(['status' => $containerStatus]);
-                                }
-                                if ($isPublic) {
-                                    $foundTcpProxy = $containers->filter(function ($value, $key) use ($uuid) {
-                                        if ($this->server->isSwarm()) {
-                                            // TODO: fix this with sentinel
-                                            return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
-                                        } else {
-                                            return data_get($value, 'name') === "$uuid-proxy";
-                                        }
-                                    })->first();
-                                    if (! $foundTcpProxy) {
-                                        StartDatabaseProxy::run($database);
-                                        $this->server->team?->notify(new ContainerRestarted("TCP Proxy for {$database->name}", $this->server));
-                                    }
-                                }
-                            } else {
-                                // Notify user that this container should not be there.
-                            }
-                        }
-                    }
-                    if (data_get($container, 'name') === 'coolify-db') {
-                        $foundDatabases[] = 0;
-                    }
-                }
-                $serviceLabelId = data_get($labels, 'coolify.serviceId');
-                if ($serviceLabelId) {
-                    $subType = data_get($labels, 'coolify.service.subType');
-                    $subId = data_get($labels, 'coolify.service.subId');
-                    $service = $services->where('id', $serviceLabelId)->first();
-                    if (! $service) {
-                        continue;
-                    }
-                    if ($subType === 'application') {
-                        $service = $service->applications()->where('id', $subId)->first();
-                    } else {
-                        $service = $service->databases()->where('id', $subId)->first();
-                    }
-                    if ($service) {
-                        $foundServices[] = "$service->id-$service->name";
-                        $statusFromDb = $service->status;
-                        if ($statusFromDb !== $containerStatus) {
-                            // ray('Updating status: ' . $containerStatus);
-                            $service->update(['status' => $containerStatus]);
-                        }
-                    }
-                }
-            }
-            $exitedServices = collect([]);
-            foreach ($services as $service) {
-                $apps = $service->applications()->get();
-                $dbs = $service->databases()->get();
-                foreach ($apps as $app) {
-                    if (in_array("$app->id-$app->name", $foundServices)) {
-                        continue;
-                    } else {
-                        $exitedServices->push($app);
-                    }
-                }
-                foreach ($dbs as $db) {
-                    if (in_array("$db->id-$db->name", $foundServices)) {
-                        continue;
-                    } else {
-                        $exitedServices->push($db);
-                    }
-                }
-            }
-            $exitedServices = $exitedServices->unique('id');
-            foreach ($exitedServices as $exitedService) {
-                if (str($exitedService->status)->startsWith('exited')) {
-                    continue;
-                }
-                $name = data_get($exitedService, 'name');
-                $fqdn = data_get($exitedService, 'fqdn');
-                if ($name) {
-                    if ($fqdn) {
-                        $containerName = "$name, available at $fqdn";
-                    } else {
-                        $containerName = $name;
-                    }
-                } else {
-                    if ($fqdn) {
-                        $containerName = $fqdn;
-                    } else {
-                        $containerName = null;
-                    }
-                }
-                $projectUuid = data_get($service, 'environment.project.uuid');
-                $serviceUuid = data_get($service, 'uuid');
-                $environmentName = data_get($service, 'environment.name');
-
-                if ($projectUuid && $serviceUuid && $environmentName) {
-                    $url = base_url().'/project/'.$projectUuid.'/'.$environmentName.'/service/'.$serviceUuid;
-                } else {
-                    $url = null;
-                }
-                // $this->server->team?->notify(new ContainerStopped($containerName, $this->server, $url));
-                $exitedService->update(['status' => 'exited']);
-            }
-
-            $notRunningApplications = $this->applications->pluck('id')->diff($foundApplications);
-            foreach ($notRunningApplications as $applicationId) {
-                $application = $this->applications->where('id', $applicationId)->first();
-                if (str($application->status)->startsWith('exited')) {
-                    continue;
-                }
-                $application->update(['status' => 'exited']);
-
-                $name = data_get($application, 'name');
-                $fqdn = data_get($application, 'fqdn');
-
-                $containerName = $name ? "$name ($fqdn)" : $fqdn;
-
-                $projectUuid = data_get($application, 'environment.project.uuid');
-                $applicationUuid = data_get($application, 'uuid');
-                $environment = data_get($application, 'environment.name');
-
-                if ($projectUuid && $applicationUuid && $environment) {
-                    $url = base_url().'/project/'.$projectUuid.'/'.$environment.'/application/'.$applicationUuid;
-                } else {
-                    $url = null;
-                }
-
-                // $this->server->team?->notify(new ContainerStopped($containerName, $this->server, $url));
-            }
-            $notRunningApplicationPreviews = $previews->pluck('id')->diff($foundApplicationPreviews);
-            foreach ($notRunningApplicationPreviews as $previewId) {
-                $preview = $previews->where('id', $previewId)->first();
-                if (str($preview->status)->startsWith('exited')) {
-                    continue;
-                }
-                $preview->update(['status' => 'exited']);
-
-                $name = data_get($preview, 'name');
-                $fqdn = data_get($preview, 'fqdn');
-
-                $containerName = $name ? "$name ($fqdn)" : $fqdn;
-
-                $projectUuid = data_get($preview, 'application.environment.project.uuid');
-                $environmentName = data_get($preview, 'application.environment.name');
-                $applicationUuid = data_get($preview, 'application.uuid');
-
-                if ($projectUuid && $applicationUuid && $environmentName) {
-                    $url = base_url().'/project/'.$projectUuid.'/'.$environmentName.'/application/'.$applicationUuid;
-                } else {
-                    $url = null;
-                }
-
-                // $this->server->team?->notify(new ContainerStopped($containerName, $this->server, $url));
-            }
-            $notRunningDatabases = $databases->pluck('id')->diff($foundDatabases);
-            foreach ($notRunningDatabases as $database) {
-                $database = $databases->where('id', $database)->first();
-                if (str($database->status)->startsWith('exited')) {
-                    continue;
-                }
-                $database->update(['status' => 'exited']);
-
-                $name = data_get($database, 'name');
-                $fqdn = data_get($database, 'fqdn');
-
-                $containerName = $name;
-
-                $projectUuid = data_get($database, 'environment.project.uuid');
-                $environmentName = data_get($database, 'environment.name');
-                $databaseUuid = data_get($database, 'uuid');
-
-                if ($projectUuid && $databaseUuid && $environmentName) {
-                    $url = base_url().'/project/'.$projectUuid.'/'.$environmentName.'/database/'.$databaseUuid;
-                } else {
-                    $url = null;
-                }
-                // $this->server->team?->notify(new ContainerStopped($containerName, $this->server, $url));
-            }
-
-            // Check if proxy is running
-            $this->server->proxyType();
-            $foundProxyContainer = $containers->filter(function ($value, $key) {
-                if ($this->server->isSwarm()) {
-                    // TODO: fix this with sentinel
-                    return data_get($value, 'Spec.Name') === 'coolify-proxy_traefik';
-                } else {
-                    return data_get($value, 'name') === 'coolify-proxy';
-                }
-            })->first();
-            if (! $foundProxyContainer) {
-                try {
-                    $shouldStart = CheckProxy::run($this->server);
-                    if ($shouldStart) {
-                        StartProxy::run($this->server, false);
-                        $this->server->team?->notify(new ContainerRestarted('coolify-proxy', $this->server));
-                    }
-                } catch (\Throwable $e) {
-                    ray($e);
-                }
-            } else {
-                $this->server->proxy->status = data_get($foundProxyContainer, 'state');
-                $this->server->save();
-                $connectProxyToDockerNetworks = connectProxyToNetworks($this->server);
-                instant_remote_process($connectProxyToDockerNetworks, $this->server, false);
-            }
-        } catch (\Exception $e) {
-            // send_internal_notification("ContainerStatusJob failed on ({$this->server->id}) with: " . $e->getMessage());
-            ray($e->getMessage());
-
-            return handleError($e);
+        if ($this->containers === null) {
+            ['containers' => $this->containers, 'containerReplicates' => $this->containerReplicates] = $this->server->getContainers();
         }
-    }
 
-    private function old_way()
-    {
-        if ($this->server->isSwarm()) {
-            $containers = instant_remote_process(["docker service inspect $(docker service ls -q) --format '{{json .}}'"], $this->server, false);
-            $containerReplicates = instant_remote_process(["docker service ls --format '{{json .}}'"], $this->server, false);
-        } else {
-            // Precheck for containers
-            $containers = instant_remote_process(['docker container ls -q'], $this->server, false);
-            if (! $containers) {
-                return;
-            }
-            $containers = instant_remote_process(["docker container inspect $(docker container ls -q) --format '{{json .}}'"], $this->server, false);
-            $containerReplicates = null;
-        }
-        if (is_null($containers)) {
+        if (is_null($this->containers)) {
             return;
         }
 
-        $containers = format_docker_command_output_to_json($containers);
-        if ($containerReplicates) {
-            $containerReplicates = format_docker_command_output_to_json($containerReplicates);
-            foreach ($containerReplicates as $containerReplica) {
+        if ($this->containerReplicates) {
+            foreach ($this->containerReplicates as $containerReplica) {
                 $name = data_get($containerReplica, 'Name');
-                $containers = $containers->map(function ($container) use ($name, $containerReplica) {
+                $this->containers = $this->containers->map(function ($container) use ($name, $containerReplica) {
                     if (data_get($container, 'Spec.Name') === $name) {
                         $replicas = data_get($containerReplica, 'Replicas');
                         $running = str($replicas)->explode('/')[0];
@@ -407,7 +83,7 @@ class GetContainersStatus
         $foundDatabases = [];
         $foundServices = [];
 
-        foreach ($containers as $container) {
+        foreach ($this->containers as $container) {
             if ($this->server->isSwarm()) {
                 $labels = data_get($container, 'Spec.Labels');
                 $uuid = data_get($labels, 'coolify.name');
@@ -431,6 +107,8 @@ class GetContainersStatus
                         $statusFromDb = $preview->status;
                         if ($statusFromDb !== $containerStatus) {
                             $preview->update(['status' => $containerStatus]);
+                        } else {
+                            $preview->update(['last_online_at' => now()]);
                         }
                     } else {
                         //Notify user that this container should not be there.
@@ -442,6 +120,8 @@ class GetContainersStatus
                         $statusFromDb = $application->status;
                         if ($statusFromDb !== $containerStatus) {
                             $application->update(['status' => $containerStatus]);
+                        } else {
+                            $application->update(['last_online_at' => now()]);
                         }
                     } else {
                         //Notify user that this container should not be there.
@@ -461,7 +141,7 @@ class GetContainersStatus
                                 if ($uuid) {
                                     $isPublic = data_get($service_db, 'is_public');
                                     if ($isPublic) {
-                                        $foundTcpProxy = $containers->filter(function ($value, $key) use ($uuid) {
+                                        $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
                                             if ($this->server->isSwarm()) {
                                                 return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
                                             } else {
@@ -484,9 +164,12 @@ class GetContainersStatus
                             $statusFromDb = $database->status;
                             if ($statusFromDb !== $containerStatus) {
                                 $database->update(['status' => $containerStatus]);
+                            } else {
+                                $database->update(['last_online_at' => now()]);
                             }
+
                             if ($isPublic) {
-                                $foundTcpProxy = $containers->filter(function ($value, $key) use ($uuid) {
+                                $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
                                     if ($this->server->isSwarm()) {
                                         return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
                                     } else {
@@ -495,7 +178,7 @@ class GetContainersStatus
                                 })->first();
                                 if (! $foundTcpProxy) {
                                     StartDatabaseProxy::run($database);
-                                    $this->server->team?->notify(new ContainerRestarted("TCP Proxy for {$database->name}", $this->server));
+                                    // $this->server->team?->notify(new ContainerRestarted("TCP Proxy for {$database->name}", $this->server));
                                 }
                             }
                         } else {
@@ -526,6 +209,8 @@ class GetContainersStatus
                     if ($statusFromDb !== $containerStatus) {
                         // ray('Updating status: ' . $containerStatus);
                         $service->update(['status' => $containerStatus]);
+                    } else {
+                        $service->update(['last_online_at' => now()]);
                     }
                 }
             }
@@ -549,7 +234,7 @@ class GetContainersStatus
                 }
             }
         }
-        $exitedServices = $exitedServices->unique('id');
+        $exitedServices = $exitedServices->unique('uuid');
         foreach ($exitedServices as $exitedService) {
             if (str($exitedService->status)->startsWith('exited')) {
                 continue;
@@ -656,31 +341,5 @@ class GetContainersStatus
             }
             // $this->server->team?->notify(new ContainerStopped($containerName, $this->server, $url));
         }
-
-        // Check if proxy is running
-        $this->server->proxyType();
-        $foundProxyContainer = $containers->filter(function ($value, $key) {
-            if ($this->server->isSwarm()) {
-                return data_get($value, 'Spec.Name') === 'coolify-proxy_traefik';
-            } else {
-                return data_get($value, 'Name') === '/coolify-proxy';
-            }
-        })->first();
-        if (! $foundProxyContainer) {
-            try {
-                $shouldStart = CheckProxy::run($this->server);
-                if ($shouldStart) {
-                    StartProxy::run($this->server, false);
-                    $this->server->team?->notify(new ContainerRestarted('coolify-proxy', $this->server));
-                }
-            } catch (\Throwable $e) {
-                ray($e);
-            }
-        } else {
-            $this->server->proxy->status = data_get($foundProxyContainer, 'State.Status');
-            $this->server->save();
-            $connectProxyToDockerNetworks = connectProxyToNetworks($this->server);
-            instant_remote_process($connectProxyToDockerNetworks, $this->server, false);
-        }
     }
 }

app/Actions/Fortify/CreateNewUser.php

@@ -2,17 +2,15 @@
 
 namespace App\Actions\Fortify;
 
-use App\Models\InstanceSettings;
 use App\Models\User;
 use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Facades\Validator;
 use Illuminate\Validation\Rule;
+use Illuminate\Validation\Rules\Password;
 use Laravel\Fortify\Contracts\CreatesNewUsers;
 
 class CreateNewUser implements CreatesNewUsers
 {
-    use PasswordValidationRules;
-
     /**
      * Validate and create a newly registered user.
      *
@@ -20,7 +18,7 @@ class CreateNewUser implements CreatesNewUsers
      */
     public function create(array $input): User
     {
-        $settings = InstanceSettings::get();
+        $settings = instanceSettings();
         if (! $settings->is_registration_enabled) {
             abort(403);
         }
@@ -33,7 +31,7 @@ class CreateNewUser implements CreatesNewUsers
                 'max:255',
                 Rule::unique(User::class),
             ],
-            'password' => $this->passwordRules(),
+            'password' => ['required', Password::defaults(), 'confirmed'],
         ])->validate();
 
         if (User::count() == 0) {
@@ -42,19 +40,19 @@ class CreateNewUser implements CreatesNewUsers
             $user = User::create([
                 'id' => 0,
                 'name' => $input['name'],
-                'email' => $input['email'],
+                'email' => strtolower($input['email']),
                 'password' => Hash::make($input['password']),
             ]);
             $team = $user->teams()->first();
 
             // Disable registration after first user is created
-            $settings = InstanceSettings::get();
+            $settings = instanceSettings();
             $settings->is_registration_enabled = false;
             $settings->save();
         } else {
             $user = User::create([
                 'name' => $input['name'],
-                'email' => $input['email'],
+                'email' => strtolower($input['email']),
                 'password' => Hash::make($input['password']),
             ]);
             $team = $user->teams()->first();

app/Actions/Fortify/PasswordValidationRules.php

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

app/Actions/Fortify/ResetUserPassword.php

@@ -5,12 +5,11 @@ namespace App\Actions\Fortify;
 use App\Models\User;
 use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Facades\Validator;
+use Illuminate\Validation\Rules\Password;
 use Laravel\Fortify\Contracts\ResetsUserPasswords;
 
 class ResetUserPassword implements ResetsUserPasswords
 {
-    use PasswordValidationRules;
-
     /**
      * Validate and reset the user's forgotten password.
      *
@@ -19,7 +18,7 @@ class ResetUserPassword implements ResetsUserPasswords
     public function reset(User $user, array $input): void
     {
         Validator::make($input, [
-            'password' => $this->passwordRules(),
+            'password' => ['required', Password::defaults(), 'confirmed'],
         ])->validate();
 
         $user->forceFill([

app/Actions/Fortify/UpdateUserPassword.php

@@ -5,12 +5,11 @@ namespace App\Actions\Fortify;
 use App\Models\User;
 use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Facades\Validator;
+use Illuminate\Validation\Rules\Password;
 use Laravel\Fortify\Contracts\UpdatesUserPasswords;
 
 class UpdateUserPassword implements UpdatesUserPasswords
 {
-    use PasswordValidationRules;
-
     /**
      * Validate and update the user's password.
      *
@@ -20,7 +19,7 @@ class UpdateUserPassword implements UpdatesUserPasswords
     {
         Validator::make($input, [
             'current_password' => ['required', 'string', 'current_password:web'],
-            'password' => $this->passwordRules(),
+            'password' => ['required', Password::defaults(), 'confirmed'],
         ], [
             'current_password.current_password' => __('The provided password does not match your current password.'),
         ])->validateWithBag('updatePassword');

app/Actions/License/CheckResaleLicense.php

@@ -2,7 +2,6 @@
 
 namespace App\Actions\License;
 
-use App\Models\InstanceSettings;
 use Illuminate\Support\Facades\Http;
 use Lorisleiva\Actions\Concerns\AsAction;
 
@@ -13,7 +12,7 @@ class CheckResaleLicense
     public function handle()
     {
         try {
-            $settings = InstanceSettings::get();
+            $settings = instanceSettings();
             if (isDev()) {
                 $settings->update([
                     'is_resale_license_active' => true,
@@ -26,8 +25,6 @@ class CheckResaleLicense
             // }
             $base_url = config('coolify.license_url');
             $instance_id = config('app.id');
-
-            ray("Checking license key against $base_url/lemon/validate");
             $data = Http::withHeaders([
                 'Accept' => 'application/json',
             ])->get("$base_url/lemon/validate", [
@@ -35,7 +32,6 @@ class CheckResaleLicense
                 'instance_id' => $instance_id,
             ])->json();
             if (data_get($data, 'valid') === true && data_get($data, 'license_key.status') === 'active') {
-                ray('Valid & active license key');
                 $settings->update([
                     'is_resale_license_active' => true,
                 ]);
@@ -49,7 +45,6 @@ class CheckResaleLicense
                 'instance_id' => $instance_id,
             ])->json();
             if (data_get($data, 'activated') === true) {
-                ray('Activated license key');
                 $settings->update([
                     'is_resale_license_active' => true,
                 ]);
@@ -61,7 +56,6 @@ class CheckResaleLicense
             }
             throw new \Exception('Cannot activate license key.');
         } catch (\Throwable $e) {
-            ray($e);
             $settings->update([
                 'resale_license' => null,
                 'is_resale_license_active' => false,

app/Actions/Proxy/CheckConfiguration.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Proxy;
 
 use App\Models\Server;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class CheckConfiguration
@@ -22,9 +21,8 @@ class CheckConfiguration
             "cat $proxy_path/docker-compose.yml",
         ];
         $proxy_configuration = instant_remote_process($payload, $server, false);
-
         if ($reset || ! $proxy_configuration || is_null($proxy_configuration)) {
-            $proxy_configuration = Str::of(generate_default_proxy_configuration($server))->trim()->value;
+            $proxy_configuration = str(generate_default_proxy_configuration($server))->trim()->value();
         }
         if (! $proxy_configuration || is_null($proxy_configuration)) {
             throw new \Exception('Could not generate proxy configuration');

app/Actions/Proxy/CheckProxy.php

@@ -2,14 +2,18 @@
 
 namespace App\Actions\Proxy;
 
+use App\Enums\ProxyTypes;
 use App\Models\Server;
+use Illuminate\Support\Facades\Log;
 use Lorisleiva\Actions\Concerns\AsAction;
+use Symfony\Component\Yaml\Yaml;
 
 class CheckProxy
 {
     use AsAction;
 
-    public function handle(Server $server, $fromUI = false)
+    // It should return if the proxy should be started (true) or not (false)
+    public function handle(Server $server, $fromUI = false): bool
     {
         if (! $server->isFunctional()) {
             return false;
@@ -26,7 +30,7 @@ class CheckProxy
         if (is_null($proxyType) || $proxyType === 'NONE' || $server->proxy->force_stop) {
             return false;
         }
-        ['uptime' => $uptime, 'error' => $error] = $server->validateConnection();
+        ['uptime' => $uptime, 'error' => $error] = $server->validateConnection(false);
         if (! $uptime) {
             throw new \Exception($error);
         }
@@ -62,22 +66,42 @@ class CheckProxy
                 $ip = 'host.docker.internal';
             }
 
-            $connection80 = @fsockopen($ip, '80');
-            $connection443 = @fsockopen($ip, '443');
-            $port80 = is_resource($connection80) && fclose($connection80);
-            $port443 = is_resource($connection443) && fclose($connection443);
-            if ($port80) {
-                if ($fromUI) {
-                    throw new \Exception("Port 80 is in use.<br>You must stop the process using this port.<br>Docs: <a target='_blank' href='https://coolify.io/docs'>https://coolify.io/docs</a><br>Discord: <a target='_blank' href='https://coollabs.io/discord'>https://coollabs.io/discord</a>");
+            $portsToCheck = ['80', '443'];
+
+            try {
+                if ($server->proxyType() !== ProxyTypes::NONE->value) {
+                    $proxyCompose = CheckConfiguration::run($server);
+                    if (isset($proxyCompose)) {
+                        $yaml = Yaml::parse($proxyCompose);
+                        $portsToCheck = [];
+                        if ($server->proxyType() === ProxyTypes::TRAEFIK->value) {
+                            $ports = data_get($yaml, 'services.traefik.ports');
+                        } elseif ($server->proxyType() === ProxyTypes::CADDY->value) {
+                            $ports = data_get($yaml, 'services.caddy.ports');
+                        }
+                        if (isset($ports)) {
+                            foreach ($ports as $port) {
+                                $portsToCheck[] = str($port)->before(':')->value();
+                            }
+                        }
+                    }
                 } else {
-                    return false;
+                    $portsToCheck = [];
                 }
+            } catch (\Exception $e) {
+                Log::error('Error checking proxy: '.$e->getMessage());
             }
-            if ($port443) {
-                if ($fromUI) {
-                    throw new \Exception("Port 443 is in use.<br>You must stop the process using this port.<br>Docs: <a target='_blank' href='https://coolify.io/docs'>https://coolify.io/docs</a><br>Discord: <a target='_blank' href='https://coollabs.io/discord'>https://coollabs.io/discord</a>");
-                } else {
-                    return false;
+            if (count($portsToCheck) === 0) {
+                return false;
+            }
+            foreach ($portsToCheck as $port) {
+                $connection = @fsockopen($ip, $port);
+                if (is_resource($connection) && fclose($connection)) {
+                    if ($fromUI) {
+                        throw new \Exception("Port $port is in use.<br>You must stop the process using this port.<br>Docs: <a target='_blank' href='https://coolify.io/docs'>https://coolify.io/docs</a><br>Discord: <a target='_blank' href='https://coollabs.io/discord'>https://coollabs.io/discord</a>");
+                    } else {
+                        return false;
+                    }
                 }
             }
 

app/Actions/Proxy/SaveConfiguration.php

@@ -3,7 +3,6 @@
 namespace App\Actions\Proxy;
 
 use App\Models\Server;
-use Illuminate\Support\Str;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class SaveConfiguration
@@ -18,7 +17,7 @@ class SaveConfiguration
         $proxy_path = $server->proxyPath();
         $docker_compose_yml_base64 = base64_encode($proxy_settings);
 
-        $server->proxy->last_saved_settings = Str::of($docker_compose_yml_base64)->pipe('md5')->value;
+        $server->proxy->last_saved_settings = str($docker_compose_yml_base64)->pipe('md5')->value;
         $server->save();
 
         return instant_remote_process([

app/Actions/Proxy/StartProxy.php

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

app/Actions/Server/CleanupDocker.php

@@ -9,16 +9,31 @@ class CleanupDocker
 {
     use AsAction;
 
-    public function handle(Server $server, bool $force = true)
+    public function handle(Server $server)
     {
-        if ($force) {
-            instant_remote_process(['docker image prune -af'], $server, false);
-            instant_remote_process(['docker container prune -f --filter "label=coolify.managed=true"'], $server, false);
-            instant_remote_process(['docker builder prune -af'], $server, false);
-        } else {
-            instant_remote_process(['docker image prune -f'], $server, false);
-            instant_remote_process(['docker container prune -f --filter "label=coolify.managed=true"'], $server, false);
-            instant_remote_process(['docker builder prune -f'], $server, false);
+        $settings = instanceSettings();
+        $helperImageVersion = data_get($settings, 'helper_version');
+        $helperImage = config('coolify.helper_image');
+        $helperImageWithVersion = "$helperImage:$helperImageVersion";
+
+        $commands = [
+            'docker container prune -f --filter "label=coolify.managed=true" --filter "label!=coolify.proxy=true"',
+            'docker image prune -af --filter "label!=coolify.managed=true"',
+            'docker builder prune -af',
+            "docker images --filter before=$helperImageWithVersion --filter reference=$helperImage | grep $helperImage | awk '{print $3}' | xargs -r docker rmi -f",
+        ];
+
+        $serverSettings = $server->settings;
+        if ($serverSettings->delete_unused_volumes) {
+            $commands[] = 'docker volume prune -af';
+        }
+
+        if ($serverSettings->delete_unused_networks) {
+            $commands[] = 'docker network prune -f';
+        }
+
+        foreach ($commands as $command) {
+            instant_remote_process([$command], $server, false);
         }
     }
 }

app/Actions/Server/ConfigureCloudflared.php

@@ -2,6 +2,7 @@
 
 namespace App\Actions\Server;
 
+use App\Events\CloudflareTunnelConfigured;
 use App\Models\Server;
 use Lorisleiva\Actions\Concerns\AsAction;
 use Symfony\Component\Yaml\Yaml;
@@ -39,9 +40,12 @@ class ConfigureCloudflared
             ]);
             instant_remote_process($commands, $server);
         } catch (\Throwable $e) {
-            ray($e);
+            $server->settings->is_cloudflare_tunnel = false;
+            $server->settings->save();
             throw $e;
         } finally {
+            CloudflareTunnelConfigured::dispatch($server->team_id);
+
             $commands = collect([
                 'rm -fr /tmp/cloudflared',
             ]);

app/Actions/Server/DeleteServer.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class DeleteServer
+{
+    use AsAction;
+
+    public function handle(Server $server)
+    {
+        StopSentinel::run($server);
+        $server->forceDelete();
+    }
+}

app/Actions/Server/InstallDocker.php

@@ -12,12 +12,11 @@ class InstallDocker
 
     public function handle(Server $server)
     {
+        $dockerVersion = config('constants.docker_install_version');
         $supported_os_type = $server->validateOS();
         if (! $supported_os_type) {
             throw new \Exception('Server OS type is not supported for automated installation. Please install Docker manually before continuing: <a target="_blank" class="underline" href="https://coolify.io/docs/installation#manually">documentation</a>.');
         }
-        ray('Installing Docker on server: '.$server->name.' ('.$server->ip.')'.' with OS type: '.$supported_os_type);
-        $dockerVersion = '24.0';
         $config = base64_encode('{
             "log-driver": "json-file",
             "log-opts": {

app/Actions/Server/ResourcesCheck.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Application;
+use App\Models\ServiceApplication;
+use App\Models\ServiceDatabase;
+use App\Models\StandaloneClickhouse;
+use App\Models\StandaloneDragonfly;
+use App\Models\StandaloneKeydb;
+use App\Models\StandaloneMariadb;
+use App\Models\StandaloneMongodb;
+use App\Models\StandaloneMysql;
+use App\Models\StandalonePostgresql;
+use App\Models\StandaloneRedis;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class ResourcesCheck
+{
+    use AsAction;
+
+    public function handle()
+    {
+        $seconds = 60;
+        try {
+            Application::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            ServiceApplication::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            ServiceDatabase::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandalonePostgresql::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneRedis::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneMongodb::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneMysql::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneMariadb::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneKeydb::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneDragonfly::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+            StandaloneClickhouse::where('last_online_at', '<', now()->subSeconds($seconds))->update(['status' => 'exited']);
+        } catch (\Throwable $e) {
+            return handleError($e);
+        }
+    }
+}

app/Actions/Server/RestartContainer.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class RestartContainer
+{
+    use AsAction;
+
+    public function handle(Server $server, string $containerName)
+    {
+        $server->restartContainer($containerName);
+    }
+}

app/Actions/Server/RunCommand.php

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

app/Actions/Server/ServerCheck.php

@@ -0,0 +1,269 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Actions\Database\StartDatabaseProxy;
+use App\Actions\Proxy\CheckProxy;
+use App\Actions\Proxy\StartProxy;
+use App\Jobs\CheckAndStartSentinelJob;
+use App\Jobs\ServerStorageCheckJob;
+use App\Models\Application;
+use App\Models\ApplicationPreview;
+use App\Models\Server;
+use App\Models\Service;
+use App\Models\ServiceApplication;
+use App\Models\ServiceDatabase;
+use App\Notifications\Container\ContainerRestarted;
+use Illuminate\Support\Arr;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class ServerCheck
+{
+    use AsAction;
+
+    public Server $server;
+
+    public bool $isSentinel = false;
+
+    public $containers;
+
+    public $databases;
+
+    public function handle(Server $server, $data = null)
+    {
+        $this->server = $server;
+        try {
+            if ($this->server->isFunctional() === false) {
+                return 'Server is not functional.';
+            }
+
+            if (! $this->server->isSwarmWorker() && ! $this->server->isBuildServer()) {
+
+                if (isset($data)) {
+                    $data = collect($data);
+
+                    $this->server->sentinelHeartbeat();
+
+                    $this->containers = collect(data_get($data, 'containers'));
+
+                    $filesystemUsageRoot = data_get($data, 'filesystem_usage_root.used_percentage');
+                    ServerStorageCheckJob::dispatch($this->server, $filesystemUsageRoot);
+
+                    $containerReplicates = null;
+                    $this->isSentinel = true;
+
+                } else {
+                    ['containers' => $this->containers, 'containerReplicates' => $containerReplicates] = $this->server->getContainers();
+                    // ServerStorageCheckJob::dispatch($this->server);
+                }
+
+                if (is_null($this->containers)) {
+                    return 'No containers found.';
+                }
+
+                if (isset($containerReplicates)) {
+                    foreach ($containerReplicates as $containerReplica) {
+                        $name = data_get($containerReplica, 'Name');
+                        $this->containers = $this->containers->map(function ($container) use ($name, $containerReplica) {
+                            if (data_get($container, 'Spec.Name') === $name) {
+                                $replicas = data_get($containerReplica, 'Replicas');
+                                $running = str($replicas)->explode('/')[0];
+                                $total = str($replicas)->explode('/')[1];
+                                if ($running === $total) {
+                                    data_set($container, 'State.Status', 'running');
+                                    data_set($container, 'State.Health.Status', 'healthy');
+                                } else {
+                                    data_set($container, 'State.Status', 'starting');
+                                    data_set($container, 'State.Health.Status', 'unhealthy');
+                                }
+                            }
+
+                            return $container;
+                        });
+                    }
+                }
+                $this->checkContainers();
+
+                if ($this->server->isSentinelEnabled() && $this->isSentinel === false) {
+                    CheckAndStartSentinelJob::dispatch($this->server);
+                }
+
+                if ($this->server->isLogDrainEnabled()) {
+                    $this->checkLogDrainContainer();
+                }
+
+                if ($this->server->proxySet() && ! $this->server->proxy->force_stop) {
+                    $foundProxyContainer = $this->containers->filter(function ($value, $key) {
+                        if ($this->server->isSwarm()) {
+                            return data_get($value, 'Spec.Name') === 'coolify-proxy_traefik';
+                        } else {
+                            return data_get($value, 'Name') === '/coolify-proxy';
+                        }
+                    })->first();
+                    if (! $foundProxyContainer) {
+                        try {
+                            $shouldStart = CheckProxy::run($this->server);
+                            if ($shouldStart) {
+                                StartProxy::run($this->server, false);
+                                $this->server->team?->notify(new ContainerRestarted('coolify-proxy', $this->server));
+                            }
+                        } catch (\Throwable $e) {
+                        }
+                    } else {
+                        $this->server->proxy->status = data_get($foundProxyContainer, 'State.Status');
+                        $this->server->save();
+                        $connectProxyToDockerNetworks = connectProxyToNetworks($this->server);
+                        instant_remote_process($connectProxyToDockerNetworks, $this->server, false);
+                    }
+                }
+            }
+        } catch (\Throwable $e) {
+            return handleError($e);
+        }
+    }
+
+    private function checkLogDrainContainer()
+    {
+        $foundLogDrainContainer = $this->containers->filter(function ($value, $key) {
+            return data_get($value, 'Name') === '/coolify-log-drain';
+        })->first();
+        if ($foundLogDrainContainer) {
+            $status = data_get($foundLogDrainContainer, 'State.Status');
+            if ($status !== 'running') {
+                StartLogDrain::dispatch($this->server)->onQueue('high');
+            }
+        } else {
+            StartLogDrain::dispatch($this->server)->onQueue('high');
+        }
+    }
+
+    private function checkContainers()
+    {
+        foreach ($this->containers as $container) {
+            if ($this->isSentinel) {
+                $labels = Arr::undot(data_get($container, 'labels'));
+            } else {
+                if ($this->server->isSwarm()) {
+                    $labels = Arr::undot(data_get($container, 'Spec.Labels'));
+                } else {
+                    $labels = Arr::undot(data_get($container, 'Config.Labels'));
+                }
+
+            }
+            $managed = data_get($labels, 'coolify.managed');
+            if (! $managed) {
+                continue;
+            }
+            $uuid = data_get($labels, 'coolify.name');
+            if (! $uuid) {
+                $uuid = data_get($labels, 'com.docker.compose.service');
+            }
+
+            if ($this->isSentinel) {
+                $containerStatus = data_get($container, 'state');
+                $containerHealth = data_get($container, 'health_status');
+            } else {
+                $containerStatus = data_get($container, 'State.Status');
+                $containerHealth = data_get($container, 'State.Health.Status', 'unhealthy');
+            }
+            $containerStatus = "$containerStatus ($containerHealth)";
+
+            $applicationId = data_get($labels, 'coolify.applicationId');
+            $serviceId = data_get($labels, 'coolify.serviceId');
+            $databaseId = data_get($labels, 'coolify.databaseId');
+            $pullRequestId = data_get($labels, 'coolify.pullRequestId');
+
+            if ($applicationId) {
+                // Application
+                if ($pullRequestId != 0) {
+                    if (str($applicationId)->contains('-')) {
+                        $applicationId = str($applicationId)->before('-');
+                    }
+                    $preview = ApplicationPreview::where('application_id', $applicationId)->where('pull_request_id', $pullRequestId)->first();
+                    if ($preview) {
+                        $preview->update(['status' => $containerStatus]);
+                    }
+                } else {
+                    $application = Application::where('id', $applicationId)->first();
+                    if ($application) {
+                        $application->update([
+                            'status' => $containerStatus,
+                            'last_online_at' => now(),
+                        ]);
+                    }
+                }
+            } elseif (isset($serviceId)) {
+                // Service
+                $subType = data_get($labels, 'coolify.service.subType');
+                $subId = data_get($labels, 'coolify.service.subId');
+                $service = Service::where('id', $serviceId)->first();
+                if (! $service) {
+                    continue;
+                }
+                if ($subType === 'application') {
+                    $service = ServiceApplication::where('id', $subId)->first();
+                } else {
+                    $service = ServiceDatabase::where('id', $subId)->first();
+                }
+                if ($service) {
+                    $service->update([
+                        'status' => $containerStatus,
+                        'last_online_at' => now(),
+                    ]);
+                    if ($subType === 'database') {
+                        $isPublic = data_get($service, 'is_public');
+                        if ($isPublic) {
+                            $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
+                                if ($this->isSentinel) {
+                                    return data_get($value, 'name') === $uuid.'-proxy';
+                                } else {
+
+                                    if ($this->server->isSwarm()) {
+                                        return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
+                                    } else {
+                                        return data_get($value, 'Name') === "/$uuid-proxy";
+                                    }
+                                }
+                            })->first();
+                            if (! $foundTcpProxy) {
+                                StartDatabaseProxy::run($service);
+                            }
+                        }
+                    }
+                }
+            } else {
+                // Database
+                if (is_null($this->databases)) {
+                    $this->databases = $this->server->databases();
+                }
+                $database = $this->databases->where('uuid', $uuid)->first();
+                if ($database) {
+                    $database->update([
+                        'status' => $containerStatus,
+                        'last_online_at' => now(),
+                    ]);
+
+                    $isPublic = data_get($database, 'is_public');
+                    if ($isPublic) {
+                        $foundTcpProxy = $this->containers->filter(function ($value, $key) use ($uuid) {
+                            if ($this->isSentinel) {
+                                return data_get($value, 'name') === $uuid.'-proxy';
+                            } else {
+                                if ($this->server->isSwarm()) {
+                                    return data_get($value, 'Spec.Name') === "coolify-proxy_$uuid";
+                                } else {
+
+                                    return data_get($value, 'Name') === "/$uuid-proxy";
+                                }
+                            }
+                        })->first();
+                        if (! $foundTcpProxy) {
+                            StartDatabaseProxy::run($database);
+                            // $this->server->team?->notify(new ContainerRestarted("TCP Proxy for {$database->name}", $this->server));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

app/Actions/Server/StartLogDrain.php

@@ -5,7 +5,7 @@ namespace App\Actions\Server;
 use App\Models\Server;
 use Lorisleiva\Actions\Concerns\AsAction;
 
-class InstallLogDrain
+class StartLogDrain
 {
     use AsAction;
 
@@ -13,23 +13,22 @@ class InstallLogDrain
     {
         if ($server->settings->is_logdrain_newrelic_enabled) {
             $type = 'newrelic';
+            StopLogDrain::run($server);
         } elseif ($server->settings->is_logdrain_highlight_enabled) {
             $type = 'highlight';
+            StopLogDrain::run($server);
         } elseif ($server->settings->is_logdrain_axiom_enabled) {
             $type = 'axiom';
+            StopLogDrain::run($server);
         } elseif ($server->settings->is_logdrain_custom_enabled) {
             $type = 'custom';
+            StopLogDrain::run($server);
         } else {
             $type = 'none';
         }
         try {
             if ($type === 'none') {
-                $command = [
-                    "echo 'Stopping old Fluent Bit'",
-                    'docker rm -f coolify-log-drain || true',
-                ];
-
-                return instant_remote_process($command, $server);
+                return 'No log drain is enabled.';
             } elseif ($type === 'newrelic') {
                 if (! $server->settings->is_logdrain_newrelic_enabled) {
                     throw new \Exception('New Relic log drain is not enabled.');
@@ -52,7 +51,11 @@ class InstallLogDrain
 [FILTER]
     Name                modify
     Match               *
-    Set                 server_name {$server->name}
+    Set                 coolify.server_name {$server->name}
+    Rename              COOLIFY_APP_NAME coolify.app_name
+    Rename              COOLIFY_PROJECT_NAME coolify.project_name
+    Rename              COOLIFY_SERVER_IP coolify.server_ip
+    Rename              COOLIFY_ENVIRONMENT_NAME coolify.environment_name
 [OUTPUT]
     Name nrlogs
     Match *
@@ -103,7 +106,11 @@ class InstallLogDrain
 [FILTER]
     Name                modify
     Match               *
-    Set                 server_name {$server->name}
+    Set                 coolify.server_name {$server->name}
+    Rename              COOLIFY_APP_NAME coolify.app_name
+    Rename              COOLIFY_PROJECT_NAME coolify.project_name
+    Rename              COOLIFY_SERVER_IP coolify.server_ip
+    Rename              COOLIFY_ENVIRONMENT_NAME coolify.environment_name
 [OUTPUT]
     Name            http
     Match           *
@@ -148,6 +155,8 @@ services:
       - ./parsers.conf:/parsers.conf
     ports:
       - 127.0.0.1:24224:24224
+    labels:
+      - coolify.managed=true
     restart: unless-stopped
 ');
             $readme = base64_encode('# New Relic Log Drain
@@ -199,10 +208,8 @@ Files:
                 throw new \Exception('Unknown log drain type.');
             }
             $restart_command = [
-                "echo 'Stopping old Fluent Bit'",
-                "cd $config_path && docker compose down --remove-orphans || true",
                 "echo 'Starting Fluent Bit'",
-                "cd $config_path && docker compose up -d --remove-orphans",
+                "cd $config_path && docker compose up -d",
             ];
             $command = array_merge($command, $add_envs_command, $restart_command);
 

app/Actions/Server/StartSentinel.php

@@ -9,15 +9,57 @@ class StartSentinel
 {
     use AsAction;
 
-    public function handle(Server $server, $version = 'latest', bool $restart = false)
+    public function handle(Server $server, bool $restart = false, ?string $latestVersion = null)
     {
-        if ($restart) {
-            instant_remote_process(['docker rm -f coolify-sentinel'], $server, false);
+        if ($server->isSwarm() || $server->isBuildServer()) {
+            return;
         }
+        if ($restart) {
+            StopSentinel::run($server);
+        }
+        $version = $latestVersion ?? get_latest_sentinel_version();
+        $metricsHistory = data_get($server, 'settings.sentinel_metrics_history_days');
+        $refreshRate = data_get($server, 'settings.sentinel_metrics_refresh_rate_seconds');
+        $pushInterval = data_get($server, 'settings.sentinel_push_interval_seconds');
+        $token = data_get($server, 'settings.sentinel_token');
+        $endpoint = data_get($server, 'settings.sentinel_custom_url');
+        $debug = data_get($server, 'settings.is_sentinel_debug_enabled');
+        $mountDir = '/data/coolify/sentinel';
+        $image = "ghcr.io/coollabsio/sentinel:$version";
+        if (! $endpoint) {
+            throw new \Exception('You should set FQDN in Instance Settings.');
+        }
+        $environments = [
+            'TOKEN' => $token,
+            'DEBUG' => $debug ? 'true' : 'false',
+            'PUSH_ENDPOINT' => $endpoint,
+            'PUSH_INTERVAL_SECONDS' => $pushInterval,
+            'COLLECTOR_ENABLED' => $server->isMetricsEnabled() ? 'true' : 'false',
+            'COLLECTOR_REFRESH_RATE_SECONDS' => $refreshRate,
+            'COLLECTOR_RETENTION_PERIOD_DAYS' => $metricsHistory,
+        ];
+        $labels = [
+            'coolify.managed' => 'true',
+        ];
+        if (isDev()) {
+            // data_set($environments, 'DEBUG', 'true');
+            // $image = 'sentinel';
+            $mountDir = '/var/lib/docker/volumes/coolify_dev_coolify_data/_data/sentinel';
+        }
+        $dockerEnvironments = '-e "'.implode('" -e "', array_map(fn ($key, $value) => "$key=$value", array_keys($environments), $environments)).'"';
+        $dockerLabels = implode(' ', array_map(fn ($key, $value) => "$key=$value", array_keys($labels), $labels));
+        $dockerCommand = "docker run -d $dockerEnvironments --name coolify-sentinel -v /var/run/docker.sock:/var/run/docker.sock -v $mountDir:/app/db --pid host --health-cmd \"curl --fail http://127.0.0.1:8888/api/health || exit 1\" --health-interval 10s --health-retries 3 --add-host=host.docker.internal:host-gateway --label $dockerLabels $image";
+
         instant_remote_process([
-            "docker run --rm --pull always -d -e \"SCHEDULER=true\" --name coolify-sentinel -v /var/run/docker.sock:/var/run/docker.sock -v /data/coolify/metrics:/app/metrics -v /data/coolify/logs:/app/logs --pid host --health-cmd \"curl --fail http://127.0.0.1:8888/api/health || exit 1\" --health-interval 10s --health-retries 3 ghcr.io/coollabsio/sentinel:$version",
-            'chown -R 9999:root /data/coolify/metrics /data/coolify/logs',
-            'chmod -R 700 /data/coolify/metrics /data/coolify/logs',
-        ], $server, false);
+            'docker rm -f coolify-sentinel || true',
+            "mkdir -p $mountDir",
+            $dockerCommand,
+            "chown -R 9999:root $mountDir",
+            "chmod -R 700 $mountDir",
+        ], $server);
+
+        $server->settings->is_sentinel_enabled = true;
+        $server->settings->save();
+        $server->sentinelHeartbeat();
     }
 }

app/Actions/Server/StopLogDrain.php

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

app/Actions/Server/StopSentinel.php

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

app/Actions/Server/UpdateCoolify.php

@@ -2,8 +2,9 @@
 
 namespace App\Actions\Server;
 
-use App\Models\InstanceSettings;
+use App\Jobs\PullHelperImageJob;
 use App\Models\Server;
+use Illuminate\Support\Sleep;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class UpdateCoolify
@@ -18,46 +19,44 @@ class UpdateCoolify
 
     public function handle($manual_update = false)
     {
-        try {
-            $settings = InstanceSettings::get();
-            ray('Running InstanceAutoUpdateJob');
-            $this->server = Server::find(0);
-            if (! $this->server) {
+        if (isDev()) {
+            Sleep::for(10)->seconds();
+
+            return;
+        }
+        $settings = instanceSettings();
+        $this->server = Server::find(0);
+        if (! $this->server) {
+            return;
+        }
+        CleanupDocker::dispatch($this->server)->onQueue('high');
+        $this->latestVersion = get_latest_version_of_coolify();
+        $this->currentVersion = config('version');
+        if (! $manual_update) {
+            if (! $settings->is_auto_update_enabled) {
                 return;
             }
-            CleanupDocker::run($this->server, false);
-            $this->latestVersion = get_latest_version_of_coolify();
-            $this->currentVersion = config('version');
-            if (! $manual_update) {
-                if (! $settings->is_auto_update_enabled) {
-                    return;
-                }
-                if ($this->latestVersion === $this->currentVersion) {
-                    return;
-                }
-                if (version_compare($this->latestVersion, $this->currentVersion, '<')) {
-                    return;
-                }
+            if ($this->latestVersion === $this->currentVersion) {
+                return;
+            }
+            if (version_compare($this->latestVersion, $this->currentVersion, '<')) {
+                return;
             }
-            $this->update();
-        } catch (\Throwable $e) {
-            throw $e;
         }
+        $this->update();
+        $settings->new_version_available = false;
+        $settings->save();
     }
 
     private function update()
     {
-        if (isDev()) {
-            remote_process([
-                'sleep 10',
-            ], $this->server);
+        PullHelperImageJob::dispatch($this->server);
+
+        instant_remote_process(["docker pull -q ghcr.io/coollabsio/coolify:{$this->latestVersion}"], $this->server, false);
 
-            return;
-        }
         remote_process([
             'curl -fsSL https://cdn.coollabs.io/coolify/upgrade.sh -o /data/coolify/source/upgrade.sh',
             "bash /data/coolify/source/upgrade.sh $this->latestVersion",
         ], $this->server);
-
     }
 }

app/Actions/Server/ValidateServer.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Actions\Server;
+
+use App\Models\Server;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class ValidateServer
+{
+    use AsAction;
+
+    public ?string $uptime = null;
+
+    public ?string $error = null;
+
+    public ?string $supported_os_type = null;
+
+    public ?string $docker_installed = null;
+
+    public ?string $docker_compose_installed = null;
+
+    public ?string $docker_version = null;
+
+    public function handle(Server $server)
+    {
+        $server->update([
+            'validation_logs' => null,
+        ]);
+        ['uptime' => $this->uptime, 'error' => $error] = $server->validateConnection();
+        if (! $this->uptime) {
+            $this->error = 'Server is not reachable. Please validate your configuration and connection.<br>Check this <a target="_blank" class="text-black underline dark:text-white" href="https://coolify.io/docs/knowledge-base/server/openssh">documentation</a> for further help. <br><br><div class="text-error">Error: '.$error.'</div>';
+            $server->update([
+                'validation_logs' => $this->error,
+            ]);
+            throw new \Exception($this->error);
+        }
+        $this->supported_os_type = $server->validateOS();
+        if (! $this->supported_os_type) {
+            $this->error = 'Server OS type is not supported. Please install Docker manually before continuing: <a target="_blank" class="text-black underline dark:text-white" href="https://docs.docker.com/engine/install/#server">documentation</a>.';
+            $server->update([
+                'validation_logs' => $this->error,
+            ]);
+            throw new \Exception($this->error);
+        }
+
+        $this->docker_installed = $server->validateDockerEngine();
+        $this->docker_compose_installed = $server->validateDockerCompose();
+        if (! $this->docker_installed || ! $this->docker_compose_installed) {
+            $this->error = 'Docker Engine is not installed. Please install Docker manually before continuing: <a target="_blank" class="text-black underline dark:text-white" href="https://docs.docker.com/engine/install/#server">documentation</a>.';
+            $server->update([
+                'validation_logs' => $this->error,
+            ]);
+            throw new \Exception($this->error);
+        }
+        $this->docker_version = $server->validateDockerEngineVersion();
+
+        if ($this->docker_version) {
+            return 'OK';
+        } else {
+            $this->error = 'Docker Engine is not installed. Please install Docker manually before continuing: <a target="_blank" class="text-black underline dark:text-white" href="https://docs.docker.com/engine/install/#server">documentation</a>.';
+            $server->update([
+                'validation_logs' => $this->error,
+            ]);
+            throw new \Exception($this->error);
+        }
+    }
+}

app/Actions/Service/DeleteService.php

@@ -2,18 +2,20 @@
 
 namespace App\Actions\Service;
 
+use App\Actions\Server\CleanupDocker;
 use App\Models\Service;
+use Illuminate\Support\Facades\Log;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class DeleteService
 {
     use AsAction;
 
-    public function handle(Service $service)
+    public function handle(Service $service, bool $deleteConfigurations, bool $deleteVolumes, bool $dockerCleanup, bool $deleteConnectedNetworks)
     {
         try {
             $server = data_get($service, 'server');
-            if ($server->isFunctional()) {
+            if ($deleteVolumes && $server->isFunctional()) {
                 $storagesToDelete = collect([]);
 
                 $service->environment_variables()->delete();
@@ -33,13 +35,29 @@ class DeleteService
                 foreach ($storagesToDelete as $storage) {
                     $commands[] = "docker volume rm -f $storage->name";
                 }
-                $commands[] = "docker rm -f $service->uuid";
 
-                instant_remote_process($commands, $server, false);
+                // Execute volume deletion first, this must be done first otherwise volumes will not be deleted.
+                if (! empty($commands)) {
+                    foreach ($commands as $command) {
+                        $result = instant_remote_process([$command], $server, false);
+                        if ($result !== null && $result !== 0) {
+                            Log::error('Error deleting volumes: '.$result);
+                        }
+                    }
+                }
             }
+
+            if ($deleteConnectedNetworks) {
+                $service->delete_connected_networks($service->uuid);
+            }
+
+            instant_remote_process(["docker rm -f $service->uuid"], $server, throwError: false);
         } catch (\Exception $e) {
             throw new \Exception($e->getMessage());
         } finally {
+            if ($deleteConfigurations) {
+                $service->delete_configurations();
+            }
             foreach ($service->applications()->get() as $application) {
                 $application->forceDelete();
             }
@@ -50,6 +68,11 @@ class DeleteService
                 $task->delete();
             }
             $service->tags()->detach();
+            $service->forceDelete();
+
+            if ($dockerCleanup) {
+                CleanupDocker::dispatch($server, true);
+            }
         }
     }
 }

app/Actions/Service/RestartService.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Actions\Service;
+
+use App\Models\Service;
+use Lorisleiva\Actions\Concerns\AsAction;
+
+class RestartService
+{
+    use AsAction;
+
+    public function handle(Service $service)
+    {
+        StopService::run($service);
+
+        return StartService::run($service);
+    }
+}

app/Actions/Service/StartService.php

@@ -12,12 +12,13 @@ class StartService
 
     public function handle(Service $service)
     {
-        ray('Starting service: '.$service->name);
         $service->saveComposeConfigs();
         $commands[] = 'cd '.$service->workdir();
         $commands[] = "echo 'Saved configuration files to {$service->workdir()}.'";
-        $commands[] = "echo 'Creating Docker network.'";
-        $commands[] = "docker network inspect $service->uuid >/dev/null 2>&1 || docker network create --attachable $service->uuid";
+        if ($service->networks()->count() > 0) {
+            $commands[] = "echo 'Creating Docker network.'";
+            $commands[] = "docker network inspect $service->uuid >/dev/null 2>&1 || docker network create --attachable $service->uuid";
+        }
         $commands[] = 'echo Starting service.';
         $commands[] = "echo 'Pulling images.'";
         $commands[] = 'docker compose pull';
@@ -29,11 +30,10 @@ class StartService
             $network = $service->destination->network;
             $serviceNames = data_get(Yaml::parse($compose), 'services', []);
             foreach ($serviceNames as $serviceName => $serviceConfig) {
-                $commands[] = "docker network connect --alias {$serviceName}-{$service->uuid} $network {$serviceName}-{$service->uuid} || true";
+                $commands[] = "docker network connect --alias {$serviceName}-{$service->uuid} $network {$serviceName}-{$service->uuid} >/dev/null 2>&1 || true";
             }
         }
-        $activity = remote_process($commands, $service->server, type_uuid: $service->uuid, callEventOnFinish: 'ServiceStatusChanged');
 
-        return $activity;
+        return remote_process($commands, $service->server, type_uuid: $service->uuid, callEventOnFinish: 'ServiceStatusChanged');
     }
 }

app/Actions/Service/StopService.php

@@ -2,6 +2,7 @@
 
 namespace App\Actions\Service;
 
+use App\Actions\Server\CleanupDocker;
 use App\Models\Service;
 use Lorisleiva\Actions\Concerns\AsAction;
 
@@ -9,34 +10,25 @@ class StopService
 {
     use AsAction;
 
-    public function handle(Service $service)
+    public function handle(Service $service, bool $isDeleteOperation = false, bool $dockerCleanup = true)
     {
         try {
             $server = $service->destination->server;
             if (! $server->isFunctional()) {
                 return 'Server is not functional';
             }
-            ray('Stopping service: '.$service->name);
-            $applications = $service->applications()->get();
-            foreach ($applications as $application) {
-                instant_remote_process(["docker rm -f {$application->name}-{$service->uuid}"], $service->server);
-                $application->update(['status' => 'exited']);
-            }
-            $dbs = $service->databases()->get();
-            foreach ($dbs as $db) {
-                instant_remote_process(["docker rm -f {$db->name}-{$service->uuid}"], $service->server);
-                $db->update(['status' => 'exited']);
-            }
-            instant_remote_process(["docker network disconnect {$service->uuid} coolify-proxy 2>/dev/null"], $service->server, false);
-            instant_remote_process(["docker network rm {$service->uuid} 2>/dev/null"], $service->server, false);
-            // TODO: make notification for databases
-            // $service->environment->project->team->notify(new StatusChanged($service));
-        } catch (\Exception $e) {
-            echo $e->getMessage();
-            ray($e->getMessage());
 
+            $containersToStop = $service->getContainersToStop();
+            $service->stopContainers($containersToStop, $server);
+
+            if (! $isDeleteOperation) {
+                $service->delete_connected_networks($service->uuid);
+                if ($dockerCleanup) {
+                    CleanupDocker::dispatch($server, true);
+                }
+            }
+        } catch (\Exception $e) {
             return $e->getMessage();
         }
-
     }
 }

app/Console/Commands/CheckApplicationDeploymentQueue.php

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

app/Console/Commands/CleanupApplicationDeploymentQueue.php

@@ -7,9 +7,9 @@ use Illuminate\Console\Command;
 
 class CleanupApplicationDeploymentQueue extends Command
 {
-    protected $signature = 'cleanup:application-deployment-queue {--team-id=}';
+    protected $signature = 'cleanup:deployment-queue {--team-id=}';
 
-    protected $description = 'CleanupApplicationDeploymentQueue';
+    protected $description = 'Cleanup application deployment queue.';
 
     public function handle()
     {

app/Console/Commands/CleanupDatabase.php

@@ -7,7 +7,7 @@ use Illuminate\Support\Facades\DB;
 
 class CleanupDatabase extends Command
 {
-    protected $signature = 'cleanup:database {--yes}';
+    protected $signature = 'cleanup:database {--yes} {--keep-days=}';
 
     protected $description = 'Cleanup database';
 
@@ -18,7 +18,12 @@ class CleanupDatabase extends Command
         } else {
             echo "Running database cleanup in dry-run mode...\n";
         }
-        $keep_days = 60;
+        if (isCloud()) {
+            // Later on we can increase this to 180 days or dynamically set
+            $keep_days = $this->option('keep-days') ?? 60;
+        } else {
+            $keep_days = $this->option('keep-days') ?? 60;
+        }
         echo "Keep days: $keep_days\n";
         // Cleanup failed jobs table
         $failed_jobs = DB::table('failed_jobs')->where('failed_at', '<', now()->subDays(1));
@@ -59,6 +64,5 @@ class CleanupDatabase extends Command
         if ($this->option('yes')) {
             $webhooks->delete();
         }
-
     }
 }

app/Console/Commands/CleanupQueue.php

@@ -1,24 +0,0 @@
-<?php
-
-namespace App\Console\Commands;
-
-use Illuminate\Console\Command;
-use Illuminate\Support\Facades\Redis;
-
-class CleanupQueue extends Command
-{
-    protected $signature = 'cleanup:queue';
-
-    protected $description = 'Cleanup Queue';
-
-    public function handle()
-    {
-        echo "Running queue cleanup...\n";
-        $prefix = config('database.redis.options.prefix');
-        $keys = Redis::connection()->keys('*:laravel*');
-        foreach ($keys as $key) {
-            $keyWithoutPrefix = str_replace($prefix, '', $key);
-            Redis::connection()->del($keyWithoutPrefix);
-        }
-    }
-}

app/Console/Commands/CleanupRedis.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Redis;
+
+class CleanupRedis extends Command
+{
+    protected $signature = 'cleanup:redis';
+
+    protected $description = 'Cleanup Redis';
+
+    public function handle()
+    {
+        echo "Cleanup Redis keys.\n";
+        $prefix = config('database.redis.options.prefix');
+
+        $keys = Redis::connection()->keys('*:laravel*');
+        collect($keys)->each(function ($key) use ($prefix) {
+            $keyWithoutPrefix = str_replace($prefix, '', $key);
+            Redis::connection()->del($keyWithoutPrefix);
+        });
+
+        $queueOverlaps = Redis::connection()->keys('*laravel-queue-overlap*');
+        collect($queueOverlaps)->each(function ($key) {
+            Redis::connection()->del($key);
+        });
+    }
+}

app/Console/Commands/CleanupStuckedResources.php

@@ -2,8 +2,13 @@
 
 namespace App\Console\Commands;
 
+use App\Jobs\CleanupHelperContainersJob;
 use App\Models\Application;
+use App\Models\ApplicationDeploymentQueue;
+use App\Models\ApplicationPreview;
+use App\Models\ScheduledDatabaseBackup;
 use App\Models\ScheduledTask;
+use App\Models\Server;
 use App\Models\Service;
 use App\Models\ServiceApplication;
 use App\Models\ServiceDatabase;
@@ -25,14 +30,33 @@ class CleanupStuckedResources extends Command
 
     public function handle()
     {
-        ray('Running cleanup stucked resources.');
         echo "Running cleanup stucked resources.\n";
         $this->cleanup_stucked_resources();
     }
 
     private function cleanup_stucked_resources()
     {
-
+        try {
+            $servers = Server::all()->filter(function ($server) {
+                return $server->isFunctional();
+            });
+            foreach ($servers as $server) {
+                CleanupHelperContainersJob::dispatch($server);
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stucked resources: {$e->getMessage()}\n";
+        }
+        try {
+            $applicationsDeploymentQueue = ApplicationDeploymentQueue::get();
+            foreach ($applicationsDeploymentQueue as $applicationDeploymentQueue) {
+                if (is_null($applicationDeploymentQueue->application)) {
+                    echo "Deleting stuck application deployment queue: {$applicationDeploymentQueue->id}\n";
+                    $applicationDeploymentQueue->delete();
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck application deployment queue: {$e->getMessage()}\n";
+        }
         try {
             $applications = Application::withTrashed()->whereNotNull('deleted_at')->get();
             foreach ($applications as $application) {
@@ -42,6 +66,17 @@ class CleanupStuckedResources extends Command
         } catch (\Throwable $e) {
             echo "Error in cleaning stuck application: {$e->getMessage()}\n";
         }
+        try {
+            $applicationsPreviews = ApplicationPreview::get();
+            foreach ($applicationsPreviews as $applicationPreview) {
+                if (! data_get($applicationPreview, 'application')) {
+                    echo "Deleting stuck application preview: {$applicationPreview->uuid}\n";
+                    $applicationPreview->delete();
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck application: {$e->getMessage()}\n";
+        }
         try {
             $postgresqls = StandalonePostgresql::withTrashed()->whereNotNull('deleted_at')->get();
             foreach ($postgresqls as $postgresql) {
@@ -153,6 +188,18 @@ class CleanupStuckedResources extends Command
             echo "Error in cleaning stuck scheduledtasks: {$e->getMessage()}\n";
         }
 
+        try {
+            $scheduled_backups = ScheduledDatabaseBackup::all();
+            foreach ($scheduled_backups as $scheduled_backup) {
+                if (! $scheduled_backup->server()) {
+                    echo "Deleting stuck scheduledbackup: {$scheduled_backup->name}\n";
+                    $scheduled_backup->delete();
+                }
+            }
+        } catch (\Throwable $e) {
+            echo "Error in cleaning stuck scheduledbackups: {$e->getMessage()}\n";
+        }
+
         // Cleanup any resources that are not attached to any environment or destination or server
         try {
             $applications = Application::all();

app/Console/Commands/CleanupUnreachableServers.php

@@ -18,7 +18,7 @@ class CleanupUnreachableServers extends Command
         if ($servers->count() > 0) {
             foreach ($servers as $server) {
                 echo "Cleanup unreachable server ($server->id) with name $server->name";
-                send_internal_notification("Server $server->name is unreachable for 7 days. Cleaning up...");
+                // send_internal_notification("Server $server->name is unreachable for 7 days. Cleaning up...");
                 $server->update([
                     'ip' => '1.2.3.4',
                 ]);

app/Console/Commands/CloudCheckSubscription.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Team;
+use Illuminate\Console\Command;
+
+class CloudCheckSubscription extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'cloud:check-subscription';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Check Cloud subscriptions';
+
+    /**
+     * Execute the console command.
+     */
+    public function handle()
+    {
+        $stripe = new \Stripe\StripeClient(config('subscription.stripe_api_key'));
+        $activeSubscribers = Team::whereRelation('subscription', 'stripe_invoice_paid', true)->get();
+        foreach ($activeSubscribers as $team) {
+            $stripeSubscriptionId = $team->subscription->stripe_subscription_id;
+            $stripeInvoicePaid = $team->subscription->stripe_invoice_paid;
+            $stripeCustomerId = $team->subscription->stripe_customer_id;
+            if (! $stripeSubscriptionId) {
+                echo "Team {$team->id} has no subscription, but invoice status is: {$stripeInvoicePaid}\n";
+                echo "Link on Stripe: https://dashboard.stripe.com/customers/{$stripeCustomerId}\n";
+
+                continue;
+            }
+            $subscription = $stripe->subscriptions->retrieve($stripeSubscriptionId);
+            if ($subscription->status === 'active') {
+                continue;
+            }
+            echo "Subscription {$stripeSubscriptionId} is not active ({$subscription->status})\n";
+            echo "Link on Stripe: https://dashboard.stripe.com/subscriptions/{$stripeSubscriptionId}\n";
+        }
+    }
+}

app/Console/Commands/CloudCleanupSubscriptions.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Team;
+use Illuminate\Console\Command;
+
+class CloudCleanupSubscriptions extends Command
+{
+    protected $signature = 'cloud:cleanup-subs';
+
+    protected $description = 'Cleanup subcriptions teams';
+
+    public function handle()
+    {
+        try {
+            if (! isCloud()) {
+                $this->error('This command can only be run on cloud');
+
+                return;
+            }
+            $this->info('Cleaning up subcriptions teams');
+            $stripe = new \Stripe\StripeClient(config('subscription.stripe_api_key'));
+
+            $teams = Team::all()->filter(function ($team) {
+                return $team->id !== 0;
+            })->sortBy('id');
+            foreach ($teams as $team) {
+                if ($team) {
+                    $this->info("Checking team {$team->id}");
+                }
+                if (! data_get($team, 'subscription')) {
+                    $this->disableServers($team);
+
+                    continue;
+                }
+                // If the team has no subscription id and the invoice is paid, we need to reset the invoice paid status
+                if (! (data_get($team, 'subscription.stripe_subscription_id'))) {
+                    $this->info("Resetting invoice paid status for team {$team->id} {$team->name}");
+
+                    $team->subscription->update([
+                        'stripe_invoice_paid' => false,
+                        'stripe_trial_already_ended' => false,
+                        'stripe_subscription_id' => null,
+                    ]);
+                    $this->disableServers($team);
+
+                    continue;
+                } else {
+                    $subscription = $stripe->subscriptions->retrieve(data_get($team, 'subscription.stripe_subscription_id'), []);
+                    $status = data_get($subscription, 'status');
+                    if ($status === 'active' || $status === 'past_due') {
+                        $team->subscription->update([
+                            'stripe_invoice_paid' => true,
+                            'stripe_trial_already_ended' => false,
+                        ]);
+
+                        continue;
+                    }
+                    $this->info('Subscription status: '.$status);
+                    $this->info('Subscription id: '.data_get($team, 'subscription.stripe_subscription_id'));
+                    $confirm = $this->confirm('Do you want to cancel the subscription?', true);
+                    if (! $confirm) {
+                        $this->info("Skipping team {$team->id} {$team->name}");
+                    } else {
+                        $this->info("Cancelling subscription for team {$team->id} {$team->name}");
+                        $team->subscription->update([
+                            'stripe_invoice_paid' => false,
+                            'stripe_trial_already_ended' => false,
+                            'stripe_subscription_id' => null,
+                        ]);
+                        $this->disableServers($team);
+                    }
+                }
+            }
+        } catch (\Exception $e) {
+            $this->error($e->getMessage());
+
+            return;
+        }
+    }
+
+    private function disableServers(Team $team)
+    {
+        foreach ($team->servers as $server) {
+            if ($server->settings->is_usable === true || $server->settings->is_reachable === true || $server->ip !== '1.2.3.4') {
+                $this->info("Disabling server {$server->id} {$server->name}");
+                $server->settings()->update([
+                    'is_usable' => false,
+                    'is_reachable' => false,
+                ]);
+                $server->update([
+                    'ip' => '1.2.3.4',
+                ]);
+            }
+        }
+    }
+}

app/Console/Commands/Dev.php

@@ -9,17 +9,51 @@ use Illuminate\Support\Facades\Process;
 
 class Dev extends Command
 {
-    protected $signature = 'dev:init';
+    protected $signature = 'dev {--init} {--generate-openapi}';
 
-    protected $description = 'Init the app in dev mode';
+    protected $description = 'Helper commands for development.';
 
     public function handle()
+    {
+        if ($this->option('init')) {
+            $this->init();
+
+            return;
+        }
+        if ($this->option('generate-openapi')) {
+            $this->generateOpenApi();
+
+            return;
+        }
+    }
+
+    public function generateOpenApi()
+    {
+        // Generate OpenAPI documentation
+        echo "Generating OpenAPI documentation.\n";
+        $process = Process::run(['/var/www/html/vendor/bin/openapi', 'app', '-o', 'openapi.yaml']);
+        $error = $process->errorOutput();
+        $error = preg_replace('/^.*an object literal,.*$/m', '', $error);
+        $error = preg_replace('/^\h*\v+/m', '', $error);
+        echo $error;
+        echo $process->output();
+    }
+
+    public function init()
     {
         // Generate APP_KEY if not exists
+
         if (empty(env('APP_KEY'))) {
             echo "Generating APP_KEY.\n";
             Artisan::call('key:generate');
         }
+
+        // Generate STORAGE link if not exists
+        if (! file_exists(public_path('storage'))) {
+            echo "Generating STORAGE link.\n";
+            Artisan::call('storage:link');
+        }
+
         // Seed database if it's empty
         $settings = InstanceSettings::find(0);
         if (! $settings) {

app/Console/Commands/Emails.php

@@ -15,7 +15,6 @@ use App\Notifications\Application\DeploymentSuccess;
 use App\Notifications\Application\StatusChanged;
 use App\Notifications\Database\BackupFailed;
 use App\Notifications\Database\BackupSuccess;
-use App\Notifications\Database\DailyBackup;
 use App\Notifications\Test;
 use Exception;
 use Illuminate\Console\Command;
@@ -81,7 +80,7 @@ class Emails extends Command
         }
         set_transanctional_email_settings();
 
-        $this->mail = new MailMessage();
+        $this->mail = new MailMessage;
         $this->mail->subject('Test Email');
         switch ($type) {
             case 'updates':
@@ -107,7 +106,7 @@ class Emails extends Command
                 $confirmed = confirm('Are you sure?');
                 if ($confirmed) {
                     foreach ($emails as $email) {
-                        $this->mail = new MailMessage();
+                        $this->mail = new MailMessage;
                         $this->mail->subject('One-click Services, Docker Compose support');
                         $unsubscribeUrl = route('unsubscribe.marketing.emails', [
                             'token' => encrypt($email),
@@ -118,31 +117,13 @@ class Emails extends Command
                 }
                 break;
             case 'emails-test':
-                $this->mail = (new Test())->toMail();
-                $this->sendEmail();
-                break;
-            case 'database-backup-statuses-daily':
-                $scheduled_backups = ScheduledDatabaseBackup::all();
-                $databases = collect();
-                foreach ($scheduled_backups as $scheduled_backup) {
-                    $last_days_backups = $scheduled_backup->get_last_days_backup_status();
-                    if ($last_days_backups->isEmpty()) {
-                        continue;
-                    }
-                    $failed = $last_days_backups->where('status', 'failed');
-                    $database = $scheduled_backup->database;
-                    $databases->put($database->name, [
-                        'failed_count' => $failed->count(),
-                    ]);
-                }
-                $this->mail = (new DailyBackup($databases))->toMail();
+                $this->mail = (new Test)->toMail();
                 $this->sendEmail();
                 break;
             case 'application-deployment-success-daily':
                 $applications = Application::all();
                 foreach ($applications as $application) {
                     $deployments = $application->get_last_days_deployments();
-                    ray($deployments);
                     if ($deployments->isEmpty()) {
                         continue;
                     }
@@ -224,7 +205,7 @@ class Emails extends Command
                 //     $this->sendEmail();
                 //     break;
             case 'waitlist-invitation-link':
-                $this->mail = new MailMessage();
+                $this->mail = new MailMessage;
                 $this->mail->view('emails.waitlist-invitation', [
                     'loginLink' => 'https://coolify.io',
                 ]);
@@ -241,7 +222,7 @@ class Emails extends Command
 
                 break;
             case 'realusers-before-trial':
-                $this->mail = new MailMessage();
+                $this->mail = new MailMessage;
                 $this->mail->view('emails.before-trial-conversion');
                 $this->mail->subject('Trial period has been added for all subscription plans.');
                 $teams = Team::doesntHave('subscription')->where('id', '!=', 0)->get();
@@ -287,7 +268,7 @@ class Emails extends Command
                 foreach ($admins as $admin) {
                     $this->info($admin);
                 }
-                $this->mail = new MailMessage();
+                $this->mail = new MailMessage;
                 $this->mail->view('emails.server-lost-connection', [
                     'name' => $server->name,
                 ]);

app/Console/Commands/Init.php

@@ -2,51 +2,74 @@
 
 namespace App\Console\Commands;
 
+use App\Actions\Server\StopSentinel;
+use App\Enums\ActivityTypes;
 use App\Enums\ApplicationDeploymentStatus;
-use App\Jobs\CleanupHelperContainersJob;
 use App\Models\ApplicationDeploymentQueue;
-use App\Models\InstanceSettings;
+use App\Models\Environment;
 use App\Models\ScheduledDatabaseBackup;
 use App\Models\Server;
 use App\Models\StandalonePostgresql;
+use App\Models\User;
 use Illuminate\Console\Command;
+use Illuminate\Support\Facades\File;
 use Illuminate\Support\Facades\Http;
 
 class Init extends Command
 {
-    protected $signature = 'app:init {--full-cleanup} {--cleanup-deployments}';
+    protected $signature = 'app:init {--force-cloud}';
 
     protected $description = 'Cleanup instance related stuffs';
 
+    public $servers = null;
+
     public function handle()
     {
-        $this->alive();
-        get_public_ips();
-        $full_cleanup = $this->option('full-cleanup');
-        $cleanup_deployments = $this->option('cleanup-deployments');
-        if ($cleanup_deployments) {
-            echo "Running cleanup deployments.\n";
-            $this->cleanup_in_progress_application_deployments();
+        if (isCloud() && ! $this->option('force-cloud')) {
+            echo "Skipping init as we are on cloud and --force-cloud option is not set\n";
 
             return;
         }
-        if ($full_cleanup) {
-            // Required for falsely deleted coolify db
-            $this->restore_coolify_db_backup();
-            $this->cleanup_in_progress_application_deployments();
-            $this->cleanup_stucked_helper_containers();
-            $this->call('cleanup:queue');
-            $this->call('cleanup:stucked-resources');
-            if (! isCloud()) {
-                try {
-                    $server = Server::find(0)->first();
-                    $server->setupDynamicProxyConfiguration();
-                } catch (\Throwable $e) {
-                    echo "Could not setup dynamic configuration: {$e->getMessage()}\n";
-                }
-            }
 
-            $settings = InstanceSettings::get();
+        $this->servers = Server::all();
+        if (isCloud()) {
+        } else {
+            $this->send_alive_signal();
+            get_public_ips();
+        }
+
+        // Backward compatibility
+        // $this->disable_metrics();
+        $this->replace_slash_in_environment_name();
+        $this->restore_coolify_db_backup();
+        $this->update_user_emails();
+        //
+        $this->update_traefik_labels();
+        if (! isCloud() || $this->option('force-cloud')) {
+            $this->cleanup_unused_network_from_coolify_proxy();
+        }
+        if (isCloud()) {
+            $this->cleanup_unnecessary_dynamic_proxy_configuration();
+        } else {
+            $this->cleanup_in_progress_application_deployments();
+        }
+        $this->call('cleanup:redis');
+        $this->call('cleanup:stucked-resources');
+
+        if (isCloud()) {
+            $response = Http::retry(3, 1000)->get(config('constants.services.official'));
+            if ($response->successful()) {
+                $services = $response->json();
+                File::put(base_path('templates/service-templates.json'), json_encode($services));
+            }
+        } else {
+            try {
+                $localhost = $this->servers->where('id', 0)->first();
+                $localhost->setupDynamicProxyConfiguration();
+            } catch (\Throwable $e) {
+                echo "Could not setup dynamic configuration: {$e->getMessage()}\n";
+            }
+            $settings = instanceSettings();
             if (! is_null(env('AUTOUPDATE', null))) {
                 if (env('AUTOUPDATE') == true) {
                     $settings->update(['is_auto_update_enabled' => true]);
@@ -54,53 +77,134 @@ class Init extends Command
                     $settings->update(['is_auto_update_enabled' => false]);
                 }
             }
-
-            return;
         }
-        $this->cleanup_stucked_helper_containers();
-        $this->call('cleanup:stucked-resources');
+    }
+
+    // private function disable_metrics()
+    // {
+    //     if (version_compare('4.0.0-beta.312', config('version'), '<=')) {
+    //         foreach ($this->servers as $server) {
+    //             if ($server->settings->is_metrics_enabled === true) {
+    //                 $server->settings->update(['is_metrics_enabled' => false]);
+    //             }
+    //             if ($server->isFunctional()) {
+    //                 StopSentinel::dispatch($server)->onQueue('high');
+    //             }
+    //         }
+    //     }
+    // }
+
+    private function update_user_emails()
+    {
+        try {
+            User::whereRaw('email ~ \'[A-Z]\'')->get()->each(fn (User $user) => $user->update(['email' => strtolower($user->email)]));
+        } catch (\Throwable $e) {
+            echo "Error in updating user emails: {$e->getMessage()}\n";
+        }
+    }
+
+    private function update_traefik_labels()
+    {
+        try {
+            Server::where('proxy->type', 'TRAEFIK_V2')->update(['proxy->type' => 'TRAEFIK']);
+        } catch (\Throwable $e) {
+            echo "Error in updating traefik labels: {$e->getMessage()}\n";
+        }
+    }
+
+    private function cleanup_unnecessary_dynamic_proxy_configuration()
+    {
+        foreach ($this->servers as $server) {
+            try {
+                if (! $server->isFunctional()) {
+                    continue;
+                }
+                if ($server->id === 0) {
+                    continue;
+                }
+                $file = $server->proxyPath().'/dynamic/coolify.yaml';
+
+                return instant_remote_process([
+                    "rm -f $file",
+                ], $server, false);
+            } catch (\Throwable $e) {
+                echo "Error in cleaning up unnecessary dynamic proxy configuration: {$e->getMessage()}\n";
+            }
+        }
+    }
+
+    private function cleanup_unused_network_from_coolify_proxy()
+    {
+        foreach ($this->servers as $server) {
+            if (! $server->isFunctional()) {
+                continue;
+            }
+            if (! $server->isProxyShouldRun()) {
+                continue;
+            }
+            try {
+                ['networks' => $networks, 'allNetworks' => $allNetworks] = collectDockerNetworksByServer($server);
+                $removeNetworks = $allNetworks->diff($networks);
+                $commands = collect();
+                foreach ($removeNetworks as $network) {
+                    $out = instant_remote_process(["docker network inspect -f json $network | jq '.[].Containers | if . == {} then null else . end'"], $server, false);
+                    if (empty($out)) {
+                        $commands->push("docker network disconnect $network coolify-proxy >/dev/null 2>&1 || true");
+                        $commands->push("docker network rm $network >/dev/null 2>&1 || true");
+                    } else {
+                        $data = collect(json_decode($out, true));
+                        if ($data->count() === 1) {
+                            // If only coolify-proxy itself is connected to that network (it should not be possible, but who knows)
+                            $isCoolifyProxyItself = data_get($data->first(), 'Name') === 'coolify-proxy';
+                            if ($isCoolifyProxyItself) {
+                                $commands->push("docker network disconnect $network coolify-proxy >/dev/null 2>&1 || true");
+                                $commands->push("docker network rm $network >/dev/null 2>&1 || true");
+                            }
+                        }
+                    }
+                }
+                if ($commands->isNotEmpty()) {
+                    echo "Cleaning up unused networks from coolify proxy\n";
+                    remote_process(command: $commands, type: ActivityTypes::INLINE->value, server: $server, ignore_errors: false);
+                }
+            } catch (\Throwable $e) {
+                echo "Error in cleaning up unused networks from coolify proxy: {$e->getMessage()}\n";
+            }
+        }
     }
 
     private function restore_coolify_db_backup()
     {
-        try {
-            $database = StandalonePostgresql::withTrashed()->find(0);
-            if ($database && $database->trashed()) {
-                echo "Restoring coolify db backup\n";
-                $database->restore();
-                $scheduledBackup = ScheduledDatabaseBackup::find(0);
-                if (! $scheduledBackup) {
-                    ScheduledDatabaseBackup::create([
-                        'id' => 0,
-                        'enabled' => true,
-                        'save_s3' => false,
-                        'frequency' => '0 0 * * *',
-                        'database_id' => $database->id,
-                        'database_type' => 'App\Models\StandalonePostgresql',
-                        'team_id' => 0,
-                    ]);
+        if (version_compare('4.0.0-beta.179', config('version'), '<=')) {
+            try {
+                $database = StandalonePostgresql::withTrashed()->find(0);
+                if ($database && $database->trashed()) {
+                    echo "Restoring coolify db backup\n";
+                    $database->restore();
+                    $scheduledBackup = ScheduledDatabaseBackup::find(0);
+                    if (! $scheduledBackup) {
+                        ScheduledDatabaseBackup::create([
+                            'id' => 0,
+                            'enabled' => true,
+                            'save_s3' => false,
+                            'frequency' => '0 0 * * *',
+                            'database_id' => $database->id,
+                            'database_type' => \App\Models\StandalonePostgresql::class,
+                            'team_id' => 0,
+                        ]);
+                    }
                 }
-            }
-        } catch (\Throwable $e) {
-            echo "Error in restoring coolify db backup: {$e->getMessage()}\n";
-        }
-    }
-
-    private function cleanup_stucked_helper_containers()
-    {
-        $servers = Server::all();
-        foreach ($servers as $server) {
-            if ($server->isFunctional()) {
-                CleanupHelperContainersJob::dispatch($server);
+            } catch (\Throwable $e) {
+                echo "Error in restoring coolify db backup: {$e->getMessage()}\n";
             }
         }
     }
 
-    private function alive()
+    private function send_alive_signal()
     {
         $id = config('app.id');
         $version = config('version');
-        $settings = InstanceSettings::get();
+        $settings = instanceSettings();
         $do_not_track = data_get($settings, 'do_not_track');
         if ($do_not_track == true) {
             echo "Skipping alive as do_not_track is enabled\n";
@@ -114,34 +218,16 @@ class Init extends Command
             echo "Error in alive: {$e->getMessage()}\n";
         }
     }
-    // private function cleanup_ssh()
-    // {
 
-    // TODO: it will cleanup id.root@host.docker.internal
-    //     try {
-    //         $files = Storage::allFiles('ssh/keys');
-    //         foreach ($files as $file) {
-    //             Storage::delete($file);
-    //         }
-    //         $files = Storage::allFiles('ssh/mux');
-    //         foreach ($files as $file) {
-    //             Storage::delete($file);
-    //         }
-    //     } catch (\Throwable $e) {
-    //         echo "Error in cleaning ssh: {$e->getMessage()}\n";
-    //     }
-    // }
     private function cleanup_in_progress_application_deployments()
     {
         // Cleanup any failed deployments
-
         try {
             if (isCloud()) {
                 return;
             }
             $queued_inprogress_deployments = ApplicationDeploymentQueue::whereIn('status', [ApplicationDeploymentStatus::IN_PROGRESS->value, ApplicationDeploymentStatus::QUEUED->value])->get();
             foreach ($queued_inprogress_deployments as $deployment) {
-                ray($deployment->id, $deployment->status);
                 echo "Cleaning up deployment: {$deployment->id}\n";
                 $deployment->status = ApplicationDeploymentStatus::FAILED->value;
                 $deployment->save();
@@ -150,4 +236,17 @@ class Init extends Command
             echo "Error: {$e->getMessage()}\n";
         }
     }
+
+    private function replace_slash_in_environment_name()
+    {
+        if (version_compare('4.0.0-beta.298', config('version'), '<=')) {
+            $environments = Environment::all();
+            foreach ($environments as $environment) {
+                if (str_contains($environment->name, '/')) {
+                    $environment->name = str_replace('/', '-', $environment->name);
+                    $environment->save();
+                }
+            }
+        }
+    }
 }

app/Console/Commands/NotifyDemo.php

@@ -36,8 +36,6 @@ class NotifyDemo extends Command
 
             return;
         }
-
-        ray($channel);
     }
 
     private function showHelp()

app/Console/Commands/OpenApi.php

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

app/Console/Commands/ServicesDelete.php

@@ -96,7 +96,7 @@ class ServicesDelete extends Command
                 if (! $confirmed) {
                     break;
                 }
-                DeleteResourceJob::dispatch($toDelete);
+                DeleteResourceJob::dispatch($toDelete)->onQueue('high');
             }
         }
     }
@@ -122,7 +122,7 @@ class ServicesDelete extends Command
                 if (! $confirmed) {
                     return;
                 }
-                DeleteResourceJob::dispatch($toDelete);
+                DeleteResourceJob::dispatch($toDelete)->onQueue('high');
             }
         }
     }
@@ -148,7 +148,7 @@ class ServicesDelete extends Command
                 if (! $confirmed) {
                     return;
                 }
-                DeleteResourceJob::dispatch($toDelete);
+                DeleteResourceJob::dispatch($toDelete)->onQueue('high');
             }
         }
     }

app/Console/Commands/ServicesGenerate.php

@@ -3,128 +3,82 @@
 namespace App\Console\Commands;
 
 use Illuminate\Console\Command;
+use Illuminate\Support\Arr;
 use Symfony\Component\Yaml\Yaml;
 
 class ServicesGenerate extends Command
 {
     /**
-     * The name and signature of the console command.
-     *
-     * @var string
+     * {@inheritdoc}
      */
     protected $signature = 'services:generate';
 
     /**
-     * The console command description.
-     *
-     * @var string
+     * {@inheritdoc}
      */
     protected $description = 'Generate service-templates.yaml based on /templates/compose directory';
 
-    /**
-     * Execute the console command.
-     */
-    public function handle()
+    public function handle(): int
     {
-        $files = array_diff(scandir(base_path('templates/compose')), ['.', '..']);
-        $files = array_filter($files, function ($file) {
-            return strpos($file, '.yaml') !== false;
-        });
-        $serviceTemplatesJson = [];
-        foreach ($files as $file) {
-            $parsed = $this->process_file($file);
-            if ($parsed) {
-                $name = data_get($parsed, 'name');
-                $parsed = data_forget($parsed, 'name');
-                $serviceTemplatesJson[$name] = $parsed;
-            }
-        }
-        $serviceTemplatesJson = json_encode($serviceTemplatesJson);
-        file_put_contents(base_path('templates/service-templates.json'), $serviceTemplatesJson);
+        $serviceTemplatesJson = collect(glob(base_path('templates/compose/*.yaml')))
+            ->mapWithKeys(function ($file): array {
+                $file = basename($file);
+                $parsed = $this->processFile($file);
+
+                return $parsed === false ? [] : [
+                    Arr::pull($parsed, 'name') => $parsed,
+                ];
+            })->toJson(JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
+
+        file_put_contents(base_path('templates/service-templates.json'), $serviceTemplatesJson.PHP_EOL);
+
+        return self::SUCCESS;
     }
 
-    private function process_file($file)
+    private function processFile(string $file): false|array
     {
-        $serviceName = str($file)->before('.yaml')->value();
         $content = file_get_contents(base_path("templates/compose/$file"));
-        // $this->info($content);
-        $ignore = collect(preg_grep('/^# ignore:/', explode("\n", $content)))->values();
-        if ($ignore->count() > 0) {
-            $ignore = (bool) str($ignore[0])->after('# ignore:')->trim()->value();
-        } else {
-            $ignore = false;
-        }
-        if ($ignore) {
+
+        $data = collect(explode(PHP_EOL, $content))->mapWithKeys(function ($line): array {
+            preg_match('/^#(?<key>.*):(?<value>.*)$/U', $line, $m);
+
+            return $m ? [trim($m['key']) => trim($m['value'])] : [];
+        });
+
+        if (str($data->get('ignore'))->toBoolean()) {
             $this->info("Ignoring $file");
 
-            return;
+            return false;
         }
+
         $this->info("Processing $file");
-        $documentation = collect(preg_grep('/^# documentation:/', explode("\n", $content)))->values();
-        if ($documentation->count() > 0) {
-            $documentation = str($documentation[0])->after('# documentation:')->trim()->value();
-            $documentation = str($documentation)->append('?utm_source=coolify.io');
-        } else {
-            $documentation = 'https://coolify.io/docs';
-        }
 
-        $slogan = collect(preg_grep('/^# slogan:/', explode("\n", $content)))->values();
-        if ($slogan->count() > 0) {
-            $slogan = str($slogan[0])->after('# slogan:')->trim()->value();
-        } else {
-            $slogan = str($file)->headline()->value();
-        }
-        $logo = collect(preg_grep('/^# logo:/', explode("\n", $content)))->values();
-        if ($logo->count() > 0) {
-            $logo = str($logo[0])->after('# logo:')->trim()->value();
-        } else {
-            $logo = 'svgs/unknown.svg';
-        }
-        $minversion = collect(preg_grep('/^# minversion:/', explode("\n", $content)))->values();
-        if ($minversion->count() > 0) {
-            $minversion = str($minversion[0])->after('# minversion:')->trim()->value();
-        } else {
-            $minversion = '0.0.0';
-        }
-        $env_file = collect(preg_grep('/^# env_file:/', explode("\n", $content)))->values();
-        if ($env_file->count() > 0) {
-            $env_file = str($env_file[0])->after('# env_file:')->trim()->value();
-        } else {
-            $env_file = null;
-        }
+        $documentation = $data->get('documentation');
+        $documentation = $documentation ? $documentation.'?utm_source=coolify.io' : 'https://coolify.io/docs';
 
-        $tags = collect(preg_grep('/^# tags:/', explode("\n", $content)))->values();
-        if ($tags->count() > 0) {
-            $tags = str($tags[0])->after('# tags:')->trim()->explode(',')->map(function ($tag) {
-                return str($tag)->trim()->lower()->value();
-            })->values();
-        } else {
-            $tags = null;
-        }
-        $port = collect(preg_grep('/^# port:/', explode("\n", $content)))->values();
-        if ($port->count() > 0) {
-            $port = str($port[0])->after('# port:')->trim()->value();
-        } else {
-            $port = null;
-        }
         $json = Yaml::parse($content);
-        $yaml = base64_encode(Yaml::dump($json, 10, 2));
+        $compose = base64_encode(Yaml::dump($json, 10, 2));
+
+        $tags = str($data->get('tags'))->lower()->explode(',')->map(fn ($tag) => trim($tag))->filter();
+        $tags = $tags->isEmpty() ? null : $tags->all();
+
         $payload = [
-            'name' => $serviceName,
+            'name' => pathinfo($file, PATHINFO_FILENAME),
             'documentation' => $documentation,
-            'slogan' => $slogan,
-            'compose' => $yaml,
+            'slogan' => $data->get('slogan', str($file)->headline()),
+            'compose' => $compose,
             'tags' => $tags,
-            'logo' => $logo,
-            'minversion' => $minversion,
+            'logo' => $data->get('logo', 'svgs/coolify.png'),
+            'minversion' => $data->get('minversion', '0.0.0'),
         ];
-        if ($port) {
+
+        if ($port = $data->get('port')) {
             $payload['port'] = $port;
         }
-        if ($env_file) {
-            $env_file_content = file_get_contents(base_path("templates/compose/$env_file"));
-            $env_file_base64 = base64_encode($env_file_content);
-            $payload['envs'] = $env_file_base64;
+
+        if ($envFile = $data->get('env_file')) {
+            $envFileContent = file_get_contents(base_path("templates/compose/$envFile"));
+            $payload['envs'] = base64_encode($envFileContent);
         }
 
         return $payload;

app/Console/Commands/SyncBunny.php

@@ -16,7 +16,7 @@ class SyncBunny extends Command
      *
      * @var string
      */
-    protected $signature = 'sync:bunny {--templates} {--release}';
+    protected $signature = 'sync:bunny {--templates} {--release} {--nightly}';
 
     /**
      * The console command description.
@@ -33,6 +33,7 @@ class SyncBunny extends Command
         $that = $this;
         $only_template = $this->option('templates');
         $only_version = $this->option('release');
+        $nightly = $this->option('nightly');
         $bunny_cdn = 'https://cdn.coollabs.io';
         $bunny_cdn_path = 'coolify';
         $bunny_cdn_storage_name = 'coolcdn';
@@ -45,9 +46,15 @@ class SyncBunny extends Command
         $upgrade_script = 'upgrade.sh';
         $production_env = '.env.production';
         $service_template = 'service-templates.json';
-
         $versions = 'versions.json';
 
+        $compose_file_location = "$parent_dir/$compose_file";
+        $compose_file_prod_location = "$parent_dir/$compose_file_prod";
+        $install_script_location = "$parent_dir/scripts/install.sh";
+        $upgrade_script_location = "$parent_dir/scripts/upgrade.sh";
+        $production_env_location = "$parent_dir/.env.production";
+        $versions_location = "$parent_dir/$versions";
+
         PendingRequest::macro('storage', function ($fileName) use ($that) {
             $headers = [
                 'AccessKey' => env('BUNNY_STORAGE_API_KEY'),
@@ -73,8 +80,26 @@ class SyncBunny extends Command
             ]);
         });
         try {
+            if ($nightly) {
+                $bunny_cdn_path = 'coolify-nightly';
+
+                $compose_file_location = "$parent_dir/other/nightly/$compose_file";
+                $compose_file_prod_location = "$parent_dir/other/nightly/$compose_file_prod";
+                $production_env_location = "$parent_dir/other/nightly/$production_env";
+                $upgrade_script_location = "$parent_dir/other/nightly/$upgrade_script";
+                $install_script_location = "$parent_dir/other/nightly/$install_script";
+                $versions_location = "$parent_dir/other/nightly/$versions";
+            }
             if (! $only_template && ! $only_version) {
-                $this->info('About to sync files (docker-compose.prod.yaml, upgrade.sh, install.sh, etc) to BunnyCDN.');
+                if ($nightly) {
+                    $this->info('About to sync files NIGHTLY (docker-compose.prod.yaml, upgrade.sh, install.sh, etc) to BunnyCDN.');
+                } else {
+                    $this->info('About to sync files PRODUCTION (docker-compose.yml, docker-compose.prod.yml, upgrade.sh, install.sh, etc) to BunnyCDN.');
+                }
+                $confirmed = confirm('Are you sure you want to sync?');
+                if (! $confirmed) {
+                    return;
+                }
             }
             if ($only_template) {
                 $this->info('About to sync service-templates.json to BunnyCDN.');
@@ -90,8 +115,12 @@ class SyncBunny extends Command
 
                 return;
             } elseif ($only_version) {
-                $this->info('About to sync versions.json to BunnyCDN.');
-                $file = file_get_contents("$parent_dir/$versions");
+                if ($nightly) {
+                    $this->info('About to sync NIGHLTY versions.json to BunnyCDN.');
+                } else {
+                    $this->info('About to sync PRODUCTION versions.json to BunnyCDN.');
+                }
+                $file = file_get_contents($versions_location);
                 $json = json_decode($file, true);
                 $actual_version = data_get($json, 'coolify.v4.version');
 
@@ -100,7 +129,7 @@ class SyncBunny extends Command
                     return;
                 }
                 Http::pool(fn (Pool $pool) => [
-                    $pool->storage(fileName: "$parent_dir/$versions")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$versions"),
+                    $pool->storage(fileName: $versions_location)->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$versions"),
                     $pool->purge("$bunny_cdn/$bunny_cdn_path/$versions"),
                 ]);
                 $this->info('versions.json uploaded & purged...');
@@ -109,11 +138,11 @@ class SyncBunny extends Command
             }
 
             Http::pool(fn (Pool $pool) => [
-                $pool->storage(fileName: "$parent_dir/$compose_file")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$compose_file"),
-                $pool->storage(fileName: "$parent_dir/$compose_file_prod")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$compose_file_prod"),
-                $pool->storage(fileName: "$parent_dir/$production_env")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$production_env"),
-                $pool->storage(fileName: "$parent_dir/scripts/$upgrade_script")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$upgrade_script"),
-                $pool->storage(fileName: "$parent_dir/scripts/$install_script")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$install_script"),
+                $pool->storage(fileName: "$compose_file_location")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$compose_file"),
+                $pool->storage(fileName: "$compose_file_prod_location")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$compose_file_prod"),
+                $pool->storage(fileName: "$production_env_location")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$production_env"),
+                $pool->storage(fileName: "$upgrade_script_location")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$upgrade_script"),
+                $pool->storage(fileName: "$install_script_location")->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$install_script"),
             ]);
             Http::pool(fn (Pool $pool) => [
                 $pool->purge("$bunny_cdn/$bunny_cdn_path/$compose_file"),

app/Console/Commands/WaitlistInvite.php

@@ -82,7 +82,7 @@ class WaitlistInvite extends Command
         if (! $already_registered) {
             $this->password = Str::password();
             User::create([
-                'name' => Str::of($this->next_patient->email)->before('@'),
+                'name' => str($this->next_patient->email)->before('@'),
                 'email' => $this->next_patient->email,
                 'password' => Hash::make($this->password),
                 'force_password_reset' => true,
@@ -103,7 +103,7 @@ class WaitlistInvite extends Command
     {
         $token = Crypt::encryptString("{$this->next_patient->email}@@@$this->password");
         $loginLink = route('auth.link', ['token' => $token]);
-        $mail = new MailMessage();
+        $mail = new MailMessage;
         $mail->view('emails.waitlist-invitation', [
             'loginLink' => $loginLink,
         ]);

app/Console/Commands/Weird.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Actions\Server\ServerCheck;
+use App\Enums\ProxyStatus;
+use App\Enums\ProxyTypes;
+use App\Models\Server;
+use Illuminate\Console\Command;
+use Str;
+
+class Weird extends Command
+{
+    protected $signature = 'weird {--number=1} {--run}';
+
+    protected $description = 'Weird stuff';
+
+    public function handle()
+    {
+        try {
+            if (! isDev()) {
+                $this->error('This command can only be run in development mode');
+
+                return;
+            }
+            $run = $this->option('run');
+            if ($run) {
+                $servers = Server::all();
+                foreach ($servers as $server) {
+                    ServerCheck::dispatch($server);
+                }
+
+                return;
+            }
+            $number = $this->option('number');
+            for ($i = 0; $i < $number; $i++) {
+                $uuid = Str::uuid();
+                $server = Server::create([
+                    'name' => 'localhost-'.$uuid,
+                    'description' => 'This is a test docker container in development mode',
+                    'ip' => 'coolify-testing-host',
+                    'team_id' => 0,
+                    'private_key_id' => 1,
+                    'proxy' => [
+                        'type' => ProxyTypes::NONE->value,
+                        'status' => ProxyStatus::EXITED->value,
+                    ],
+                ]);
+                $server->settings->update([
+                    'is_usable' => true,
+                    'is_reachable' => true,
+                ]);
+            }
+        } catch (\Exception $e) {
+            $this->error($e->getMessage());
+        }
+    }
+}

app/Console/Kernel.php

@@ -2,135 +2,195 @@
 
 namespace App\Console;
 
-use App\Jobs\CheckLogDrainContainerJob;
+use App\Jobs\CheckAndStartSentinelJob;
+use App\Jobs\CheckForUpdatesJob;
+use App\Jobs\CheckHelperImageJob;
 use App\Jobs\CleanupInstanceStuffsJob;
-use App\Jobs\ContainerStatusJob;
+use App\Jobs\CleanupStaleMultiplexedConnections;
 use App\Jobs\DatabaseBackupJob;
-use App\Jobs\PullCoolifyImageJob;
-use App\Jobs\PullHelperImageJob;
-use App\Jobs\PullSentinelImageJob;
+use App\Jobs\DockerCleanupJob;
 use App\Jobs\PullTemplatesFromCDN;
 use App\Jobs\ScheduledTaskJob;
-use App\Jobs\ServerStatusJob;
+use App\Jobs\ServerCheckJob;
+use App\Jobs\ServerCleanupMux;
+use App\Jobs\ServerStorageCheckJob;
+use App\Jobs\UpdateCoolifyJob;
+use App\Models\InstanceSettings;
 use App\Models\ScheduledDatabaseBackup;
 use App\Models\ScheduledTask;
 use App\Models\Server;
 use App\Models\Team;
 use Illuminate\Console\Scheduling\Schedule;
 use Illuminate\Foundation\Console\Kernel as ConsoleKernel;
+use Illuminate\Support\Carbon;
 
 class Kernel extends ConsoleKernel
 {
-    private $all_servers;
+    private $allServers;
+
+    private InstanceSettings $settings;
+
+    private string $updateCheckFrequency;
+
+    private string $instanceTimezone;
 
     protected function schedule(Schedule $schedule): void
     {
-        $this->all_servers = Server::all();
+        $this->allServers = Server::where('ip', '!=', '1.2.3.4');
+
+        $this->settings = instanceSettings();
+        $this->updateCheckFrequency = $this->settings->update_check_frequency ?: '0 * * * *';
+        $this->instanceTimezone = $this->settings->instance_timezone ?: config('app.timezone');
+
+        $schedule->job(new CleanupStaleMultiplexedConnections)->hourly();
+
         if (isDev()) {
             // Instance Jobs
             $schedule->command('horizon:snapshot')->everyMinute();
             $schedule->job(new CleanupInstanceStuffsJob)->everyMinute()->onOneServer();
-            $schedule->job(new PullTemplatesFromCDN)->everyTwoHours()->onOneServer();
+            $schedule->job(new CheckHelperImageJob)->everyTenMinutes()->onOneServer();
+
             // Server Jobs
-            $this->check_scheduled_backups($schedule);
-            $this->check_resources($schedule);
-            $this->check_scheduled_backups($schedule);
-            $this->check_scheduled_tasks($schedule);
+            $this->checkResources($schedule);
+
+            $this->checkScheduledBackups($schedule);
+            $this->checkScheduledTasks($schedule);
+
             $schedule->command('uploads:clear')->everyTwoMinutes();
+
         } else {
             // Instance Jobs
             $schedule->command('horizon:snapshot')->everyFiveMinutes();
-            $schedule->command('cleanup:unreachable-servers')->daily();
-            $schedule->job(new PullCoolifyImageJob)->everyTenMinutes()->onOneServer();
-            $schedule->job(new PullTemplatesFromCDN)->everyThirtyMinutes()->onOneServer();
+            $schedule->command('cleanup:unreachable-servers')->daily()->onOneServer();
+            $schedule->job(new PullTemplatesFromCDN)->cron($this->updateCheckFrequency)->timezone($this->instanceTimezone)->onOneServer();
             $schedule->job(new CleanupInstanceStuffsJob)->everyTwoMinutes()->onOneServer();
-            // $schedule->job(new CheckResaleLicenseJob)->hourly()->onOneServer();
+            $this->scheduleUpdates($schedule);
 
             // Server Jobs
-            $this->check_scheduled_backups($schedule);
-            $this->check_resources($schedule);
-            $this->pull_images($schedule);
-            $this->check_scheduled_tasks($schedule);
+            $this->checkResources($schedule);
+
+            $this->pullImages($schedule);
+
+            $this->checkScheduledBackups($schedule);
+            $this->checkScheduledTasks($schedule);
 
             $schedule->command('cleanup:database --yes')->daily();
             $schedule->command('uploads:clear')->everyTwoMinutes();
         }
     }
 
-    private function pull_images($schedule)
+    private function pullImages($schedule): void
     {
-        $servers = $this->all_servers->where('settings.is_usable', true)->where('settings.is_reachable', true)->where('ip', '!=', '1.2.3.4');
+        $servers = $this->allServers->whereRelation('settings', 'is_usable', true)->whereRelation('settings', 'is_reachable', true)->get();
         foreach ($servers as $server) {
-            if (config('coolify.is_sentinel_enabled')) {
-                $schedule->job(new PullSentinelImageJob($server))->everyFiveMinutes()->onOneServer();
+            if ($server->isSentinelEnabled()) {
+                $schedule->job(function () use ($server) {
+                    CheckAndStartSentinelJob::dispatch($server);
+                })->cron($this->updateCheckFrequency)->timezone($this->instanceTimezone)->onOneServer();
             }
-            $schedule->job(new PullHelperImageJob($server))->everyFiveMinutes()->onOneServer();
+        }
+        $schedule->job(new CheckHelperImageJob)
+            ->cron($this->updateCheckFrequency)
+            ->timezone($this->instanceTimezone)
+            ->onOneServer();
+    }
+
+    private function scheduleUpdates($schedule): void
+    {
+        $schedule->job(new CheckForUpdatesJob)
+            ->cron($this->updateCheckFrequency)
+            ->timezone($this->instanceTimezone)
+            ->onOneServer();
+
+        if ($this->settings->is_auto_update_enabled) {
+            $autoUpdateFrequency = $this->settings->auto_update_frequency;
+            $schedule->job(new UpdateCoolifyJob)
+                ->cron($autoUpdateFrequency)
+                ->timezone($this->instanceTimezone)
+                ->onOneServer();
         }
     }
 
-    private function check_resources($schedule)
+    private function checkResources($schedule): void
     {
         if (isCloud()) {
-            $servers = $this->all_servers->whereNotNull('team.subscription')->where('team.subscription.stripe_trial_already_ended', false)->where('ip', '!=', '1.2.3.4');
+            $servers = $this->allServers->whereHas('team.subscription')->get();
             $own = Team::find(0)->servers;
             $servers = $servers->merge($own);
-            $containerServers = $servers->where('settings.is_swarm_worker', false)->where('settings.is_build_server', false);
         } else {
-            $servers = $this->all_servers->where('ip', '!=', '1.2.3.4');
-            $containerServers = $servers->where('settings.is_swarm_worker', false)->where('settings.is_build_server', false);
-        }
-        foreach ($containerServers as $server) {
-            $schedule->job(new ContainerStatusJob($server))->everyMinute()->onOneServer();
-            if ($server->isLogDrainEnabled()) {
-                $schedule->job(new CheckLogDrainContainerJob($server))->everyMinute()->onOneServer();
-            }
+            $servers = $this->allServers->get();
         }
+
         foreach ($servers as $server) {
-            $schedule->job(new ServerStatusJob($server))->everyMinute()->onOneServer();
+            $serverTimezone = $server->settings->server_timezone;
+
+            // Sentinel check
+            $lastSentinelUpdate = $server->sentinel_updated_at;
+            if (Carbon::parse($lastSentinelUpdate)->isBefore(now()->subSeconds($server->waitBeforeDoingSshCheck()))) {
+                // Check container status every minute if Sentinel does not activated
+                $schedule->job(new ServerCheckJob($server))->everyMinute()->onOneServer();
+                // $schedule->job(new \App\Jobs\ServerCheckNewJob($server))->everyMinute()->onOneServer();
+
+                // Check storage usage every 10 minutes if Sentinel does not activated
+                $schedule->job(new ServerStorageCheckJob($server))->everyTenMinutes()->onOneServer();
+            }
+            if ($server->settings->force_docker_cleanup) {
+                $schedule->job(new DockerCleanupJob($server))->cron($server->settings->docker_cleanup_frequency)->timezone($serverTimezone)->onOneServer();
+            } else {
+                $schedule->job(new DockerCleanupJob($server))->everyTenMinutes()->timezone($serverTimezone)->onOneServer();
+            }
+
+            // Cleanup multiplexed connections every hour
+            $schedule->job(new ServerCleanupMux($server))->hourly()->onOneServer();
+
+            // Temporary solution until we have better memory management for Sentinel
+            if ($server->isSentinelEnabled()) {
+                $schedule->job(function () use ($server) {
+                    $server->restartContainer('coolify-sentinel');
+                })->daily()->onOneServer();
+            }
         }
     }
 
-    private function check_scheduled_backups($schedule)
+    private function checkScheduledBackups($schedule): void
     {
-        $scheduled_backups = ScheduledDatabaseBackup::all();
+        $scheduled_backups = ScheduledDatabaseBackup::where('enabled', true)->get();
         if ($scheduled_backups->isEmpty()) {
             return;
         }
         foreach ($scheduled_backups as $scheduled_backup) {
-            if (! $scheduled_backup->enabled) {
-                continue;
-            }
             if (is_null(data_get($scheduled_backup, 'database'))) {
-                ray('database not found');
                 $scheduled_backup->delete();
 
                 continue;
             }
 
+            $server = $scheduled_backup->server();
+
+            if (is_null($server)) {
+                continue;
+            }
+
             if (isset(VALID_CRON_STRINGS[$scheduled_backup->frequency])) {
                 $scheduled_backup->frequency = VALID_CRON_STRINGS[$scheduled_backup->frequency];
             }
             $schedule->job(new DatabaseBackupJob(
                 backup: $scheduled_backup
-            ))->cron($scheduled_backup->frequency)->onOneServer();
+            ))->cron($scheduled_backup->frequency)->timezone($this->instanceTimezone)->onOneServer();
         }
     }
 
-    private function check_scheduled_tasks($schedule)
+    private function checkScheduledTasks($schedule): void
     {
-        $scheduled_tasks = ScheduledTask::all();
+        $scheduled_tasks = ScheduledTask::where('enabled', true)->get();
         if ($scheduled_tasks->isEmpty()) {
             return;
         }
         foreach ($scheduled_tasks as $scheduled_task) {
-            if ($scheduled_task->enabled === false) {
-                continue;
-            }
             $service = $scheduled_task->service;
             $application = $scheduled_task->application;
 
             if (! $application && ! $service) {
-                ray('application/service attached to scheduled task does not exist');
                 $scheduled_task->delete();
 
                 continue;
@@ -145,12 +205,18 @@ class Kernel extends ConsoleKernel
                     continue;
                 }
             }
+
+            $server = $scheduled_task->server();
+            if (! $server) {
+                continue;
+            }
+
             if (isset(VALID_CRON_STRINGS[$scheduled_task->frequency])) {
                 $scheduled_task->frequency = VALID_CRON_STRINGS[$scheduled_task->frequency];
             }
             $schedule->job(new ScheduledTaskJob(
                 task: $scheduled_task
-            ))->cron($scheduled_task->frequency)->onOneServer();
+            ))->cron($scheduled_task->frequency)->timezone($this->instanceTimezone)->onOneServer();
         }
     }
 

app/Data/ServerMetadata.php

@@ -11,6 +11,5 @@ class ServerMetadata extends Data
     public function __construct(
         public ?ProxyTypes $type,
         public ?ProxyStatus $status
-    ) {
-    }
+    ) {}
 }

app/Enums/ActivityTypes.php

@@ -5,4 +5,5 @@ namespace App\Enums;
 enum ActivityTypes: string
 {
     case INLINE = 'inline';
+    case COMMAND = 'command';
 }

app/Enums/BuildPackTypes.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Enums;
+
+enum BuildPackTypes: string
+{
+    case NIXPACKS = 'nixpacks';
+    case STATIC = 'static';
+    case DOCKERFILE = 'dockerfile';
+    case DOCKERCOMPOSE = 'dockercompose';
+}

app/Enums/ContainerStatusTypes.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Enums;
+
+enum ContainerStatusTypes: string
+{
+    case PAUSED = 'paused';
+    case RESTARTING = 'restarting';
+    case REMOVING = 'removing';
+    case RUNNING = 'running';
+    case DEAD = 'dead';
+    case CREATED = 'created';
+    case EXITED = 'exited';
+}

app/Enums/NewDatabaseTypes.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Enums;
+
+enum NewDatabaseTypes: string
+{
+    case POSTGRESQL = 'postgresql';
+    case MYSQL = 'mysql';
+    case MONGODB = 'mongodb';
+    case REDIS = 'redis';
+    case MARIADB = 'mariadb';
+    case KEYDB = 'keydb';
+    case DRAGONFLY = 'dragonfly';
+    case CLICKHOUSE = 'clickhouse';
+}

app/Enums/NewResourceTypes.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Enums;
+
+enum NewResourceTypes: string
+{
+    case PUBLIC = 'public';
+    case PRIVATE_GH_APP = 'private-gh-app';
+    case PRIVATE_DEPLOY_KEY = 'private-deploy-key';
+    case DOCKERFILE = 'dockerfile';
+    case DOCKERCOMPOSE = 'dockercompose';
+    case DOCKER_IMAGE = 'docker-image';
+    case SERVICE = 'service';
+    case POSTGRESQL = 'postgresql';
+    case MYSQL = 'mysql';
+    case MONGODB = 'mongodb';
+    case REDIS = 'redis';
+    case MARIADB = 'mariadb';
+    case KEYDB = 'keydb';
+    case DRAGONFLY = 'dragonfly';
+    case CLICKHOUSE = 'clickhouse';
+}

app/Enums/ProxyTypes.php

@@ -5,7 +5,7 @@ namespace App\Enums;
 enum ProxyTypes: string
 {
     case NONE = 'NONE';
-    case TRAEFIK_V2 = 'TRAEFIK_V2';
+    case TRAEFIK = 'TRAEFIK';
     case NGINX = 'NGINX';
     case CADDY = 'CADDY';
 }

app/Enums/RedirectTypes.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Enums;
+
+enum RedirectTypes: string
+{
+    case BOTH = 'both';
+    case WWW = 'www';
+    case NON_WWW = 'non-www';
+}

app/Enums/Role.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Enums;
+
+enum Role: string
+{
+    case MEMBER = 'member';
+    case ADMIN = 'admin';
+    case OWNER = 'owner';
+
+    public function rank(): int
+    {
+        return match ($this) {
+            self::MEMBER => 1,
+            self::ADMIN => 2,
+            self::OWNER => 3,
+        };
+    }
+
+    public function lt(Role|string $role): bool
+    {
+        if (is_string($role)) {
+            $role = Role::from($role);
+        }
+
+        return $this->rank() < $role->rank();
+    }
+
+    public function gt(Role|string $role): bool
+    {
+        if (is_string($role)) {
+            $role = Role::from($role);
+        }
+
+        return $this->rank() > $role->rank();
+    }
+}

app/Enums/StaticImageTypes.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Enums;
+
+enum StaticImageTypes: string
+{
+    case NGINX_ALPINE = 'nginx:alpine';
+}

app/Events/CloudflareTunnelConfigured.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Events;
+
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Broadcasting\PrivateChannel;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class CloudflareTunnelConfigured implements ShouldBroadcast
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public $teamId;
+
+    public function __construct($teamId = null)
+    {
+        if (is_null($teamId)) {
+            $teamId = auth()->user()->currentTeam()->id ?? null;
+        }
+        if (is_null($teamId)) {
+            throw new \Exception('Team id is null');
+        }
+        $this->teamId = $teamId;
+    }
+
+    public function broadcastOn(): array
+    {
+        return [
+            new PrivateChannel("team.{$this->teamId}"),
+        ];
+    }
+}

app/Events/DatabaseProxyStopped.php

@@ -0,0 +1,35 @@
+<?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;
+use Illuminate\Support\Facades\Auth;
+
+class DatabaseProxyStopped implements ShouldBroadcast
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public $teamId;
+
+    public function __construct($teamId = null)
+    {
+        if (is_null($teamId)) {
+            $teamId = Auth::user()->currentTeam()->id ?? null;
+        }
+        if (is_null($teamId)) {
+            throw new \Exception('Team id is null');
+        }
+        $this->teamId = $teamId;
+    }
+
+    public function broadcastOn(): array
+    {
+        return [
+            new PrivateChannel("team.{$this->teamId}"),
+        ];
+    }
+}

app/Events/DatabaseStatusChanged.php

@@ -7,28 +7,34 @@ use Illuminate\Broadcasting\PrivateChannel;
 use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
 use Illuminate\Foundation\Events\Dispatchable;
 use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Auth;
 
 class DatabaseStatusChanged implements ShouldBroadcast
 {
     use Dispatchable, InteractsWithSockets, SerializesModels;
 
-    public $userId;
+    public $userId = null;
 
     public function __construct($userId = null)
     {
         if (is_null($userId)) {
-            $userId = auth()->user()->id ?? null;
+            $userId = Auth::id() ?? null;
         }
         if (is_null($userId)) {
-            throw new \Exception('User id is null');
+            return false;
         }
+
         $this->userId = $userId;
     }
 
-    public function broadcastOn(): array
+    public function broadcastOn(): ?array
     {
-        return [
-            new PrivateChannel("user.{$this->userId}"),
-        ];
+        if (! is_null($this->userId)) {
+            return [
+                new PrivateChannel("user.{$this->userId}"),
+            ];
+        }
+
+        return null;
     }
 }

app/Events/FileStorageChanged.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Events;
+
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Broadcasting\PrivateChannel;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class FileStorageChanged implements ShouldBroadcast
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public $teamId;
+
+    public function __construct($teamId = null)
+    {
+        if (is_null($teamId)) {
+            throw new \Exception('Team id is null');
+        }
+        $this->teamId = $teamId;
+    }
+
+    public function broadcastOn(): array
+    {
+        return [
+            new PrivateChannel("team.{$this->teamId}"),
+        ];
+    }
+}

app/Events/ProxyStarted.php

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

app/Events/ScheduledTaskDone.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Events;
+
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Broadcasting\PrivateChannel;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class ScheduledTaskDone implements ShouldBroadcast
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public $teamId;
+
+    public function __construct($teamId = null)
+    {
+        if (is_null($teamId)) {
+            $teamId = auth()->user()->currentTeam()->id ?? null;
+        }
+        if (is_null($teamId)) {
+            throw new \Exception('Team id is null');
+        }
+        $this->teamId = $teamId;
+    }
+
+    public function broadcastOn(): array
+    {
+        return [
+            new PrivateChannel("team.{$this->teamId}"),
+        ];
+    }
+}

app/Events/ServiceStatusChanged.php

@@ -7,28 +7,33 @@ use Illuminate\Broadcasting\PrivateChannel;
 use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
 use Illuminate\Foundation\Events\Dispatchable;
 use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Auth;
 
 class ServiceStatusChanged implements ShouldBroadcast
 {
     use Dispatchable, InteractsWithSockets, SerializesModels;
 
-    public $userId;
+    public ?string $userId = null;
 
     public function __construct($userId = null)
     {
         if (is_null($userId)) {
-            $userId = auth()->user()->id ?? null;
+            $userId = Auth::id() ?? null;
         }
         if (is_null($userId)) {
-            throw new \Exception('User id is null');
+            return false;
         }
         $this->userId = $userId;
     }
 
-    public function broadcastOn(): array
+    public function broadcastOn(): ?array
     {
-        return [
-            new PrivateChannel("user.{$this->userId}"),
-        ];
+        if (! is_null($this->userId)) {
+            return [
+                new PrivateChannel("user.{$this->userId}"),
+            ];
+        }
+
+        return null;
     }
 }

app/Exceptions/Handler.php

@@ -50,7 +50,7 @@ class Handler extends ExceptionHandler
             return response()->json(['message' => $exception->getMessage()], 401);
         }
 
-        return redirect()->guest($exception->redirectTo() ?? route('login'));
+        return redirect()->guest($exception->redirectTo($request) ?? route('login'));
     }
 
     /**
@@ -65,7 +65,7 @@ class Handler extends ExceptionHandler
             if ($e instanceof RuntimeException) {
                 return;
             }
-            $this->settings = InstanceSettings::get();
+            $this->settings = instanceSettings();
             if ($this->settings->do_not_track) {
                 return;
             }
@@ -84,7 +84,6 @@ class Handler extends ExceptionHandler
             if (str($e->getMessage())->contains('No space left on device')) {
                 return;
             }
-            ray('reporting to sentry');
             Integration::captureUnhandledException($e);
         });
     }

app/Exceptions/ProcessException.php

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

app/Helpers/SshMultiplexingHelper.php

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

app/Http/Controllers/Api/Deploy.php

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

app/Http/Controllers/Api/DeployController.php

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

app/Http/Controllers/Api/Domains.php

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

app/Http/Controllers/Api/OpenApi.php

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

app/Http/Controllers/Api/OtherController.php

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

app/Http/Controllers/Api/Project.php

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

app/Http/Controllers/Api/ProjectController.php

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

app/Http/Controllers/Api/Resources.php

@@ -1,39 +0,0 @@
-<?php
-
-namespace App\Http\Controllers\Api;
-
-use App\Http\Controllers\Controller;
-use App\Models\Project;
-use Illuminate\Http\Request;
-
-class Resources extends Controller
-{
-    public function resources(Request $request)
-    {
-        $teamId = get_team_id_from_token();
-        if (is_null($teamId)) {
-            return invalid_token();
-        }
-        $projects = Project::where('team_id', $teamId)->get();
-        $resources = collect();
-        $resources->push($projects->pluck('applications')->flatten());
-        $resources->push($projects->pluck('services')->flatten());
-        foreach (collect(DATABASE_TYPES) as $db) {
-            $resources->push($projects->pluck(str($db)->plural(2))->flatten());
-        }
-        $resources = $resources->flatten();
-        $resources = $resources->map(function ($resource) {
-            $payload = $resource->toArray();
-            if ($resource->getMorphClass() === 'App\Models\Service') {
-                $payload['status'] = $resource->status();
-            } else {
-                $payload['status'] = $resource->status;
-            }
-            $payload['type'] = $resource->type();
-
-            return $payload;
-        });
-
-        return response()->json($resources);
-    }
-}

app/Http/Controllers/Api/ResourcesController.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Controllers\Controller;
+use App\Models\Project;
+use Illuminate\Http\Request;
+use OpenApi\Attributes as OA;
+
+class ResourcesController extends Controller
+{
+    #[OA\Get(
+        summary: 'List',
+        description: 'Get all resources.',
+        path: '/resources',
+        operationId: 'list-resources',
+        security: [
+            ['bearerAuth' => []],
+        ],
+        tags: ['Resources'],
+        responses: [
+            new OA\Response(
+                response: 200,
+                description: 'Get all resources',
+                content: new OA\JsonContent(
+                    type: 'string',
+                    example: 'Content is very complex. Will be implemented later.',
+                ),
+            ),
+            new OA\Response(
+                response: 401,
+                ref: '#/components/responses/401',
+            ),
+            new OA\Response(
+                response: 400,
+                ref: '#/components/responses/400',
+            ),
+        ]
+    )]
+    public function resources(Request $request)
+    {
+        $teamId = getTeamIdFromToken();
+        if (is_null($teamId)) {
+            return invalidTokenResponse();
+        }
+        $projects = Project::where('team_id', $teamId)->get();
+        $resources = collect();
+        $resources->push($projects->pluck('applications')->flatten());
+        $resources->push($projects->pluck('services')->flatten());
+        foreach (collect(DATABASE_TYPES) as $db) {
+            $resources->push($projects->pluck(str($db)->plural(2))->flatten());
+        }
+        $resources = $resources->flatten();
+        $resources = $resources->map(function ($resource) {
+            $payload = $resource->toArray();
+            if ($resource->getMorphClass() === \App\Models\Service::class) {
+                $payload['status'] = $resource->status();
+            } else {
+                $payload['status'] = $resource->status;
+            }
+            $payload['type'] = $resource->type();
+
+            return $payload;
+        });
+
+        return response()->json(serializeApiResponse($resources));
+    }
+}

app/Http/Controllers/Api/SecurityController.php

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