Change moonlight service to always fetch the changelog

Rewrite notification system

.gitignore

@@ -42,3 +42,4 @@ Desktop.ini
 
 storage/
 Moonlight/publish.ps1
+Moonlight/version

Moonlight/App/ApiClients/Daemon/DaemonApiHelper.cs

@@ -1,5 +1,4 @@
 using Moonlight.App.Database.Entities;
-using Moonlight.App.Exceptions;
 using Newtonsoft.Json;
 using RestSharp;
 
@@ -14,26 +13,13 @@ public class DaemonApiHelper
         Client = new();
     }
     
-    private string GetApiUrl(Node node)
-    {
-        /* SSL not implemented in moonlight daemon
-        if(node.Ssl)
-            return $"https://{node.Fqdn}:{node.MoonlightDaemonPort}/";
-        else
-            return $"http://{node.Fqdn}:{node.MoonlightDaemonPort}/";*/
-        
-        return $"http://{node.Fqdn}:{node.MoonlightDaemonPort}/";
-    }
-    
     public async Task<T> Get<T>(Node node, string resource)
     {
-        RestRequest request = new(GetApiUrl(node) + resource);
+        var request = await CreateRequest(node, resource);
 
-        request.AddHeader("Content-Type", "application/json");
-        request.AddHeader("Accept", "application/json");
-        request.AddHeader("Authorization", node.Token);
+        request.Method = Method.Get;
         
-        var response = await Client.GetAsync(request);
+        var response = await Client.ExecuteAsync(request);
 
         if (!response.IsSuccessful)
         {
@@ -52,4 +38,69 @@ public class DaemonApiHelper
 
         return JsonConvert.DeserializeObject<T>(response.Content!)!;
     }
+    
+    public async Task Post(Node node, string resource, object body)
+    {
+        var request = await CreateRequest(node, resource);
+
+        request.Method = Method.Post;
+
+        request.AddParameter("text/plain", JsonConvert.SerializeObject(body), ParameterType.RequestBody);
+
+        var response = await Client.ExecuteAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            if (response.StatusCode != 0)
+            {
+                throw new DaemonException(
+                    $"An error occured: ({response.StatusCode}) {response.Content}",
+                    (int)response.StatusCode
+                );
+            }
+            else
+            {
+                throw new Exception($"An internal error occured: {response.ErrorMessage}");
+            }
+        }
+    }
+    
+    public async Task Delete(Node node, string resource, object body)
+    {
+        var request = await CreateRequest(node, resource);
+
+        request.Method = Method.Delete;
+
+        request.AddParameter("text/plain", JsonConvert.SerializeObject(body), ParameterType.RequestBody);
+
+        var response = await Client.ExecuteAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            if (response.StatusCode != 0)
+            {
+                throw new DaemonException(
+                    $"An error occured: ({response.StatusCode}) {response.Content}",
+                    (int)response.StatusCode
+                );
+            }
+            else
+            {
+                throw new Exception($"An internal error occured: {response.ErrorMessage}");
+            }
+        }
+    }
+
+    private Task<RestRequest> CreateRequest(Node node, string resource)
+    {
+        var url = $"http://{node.Fqdn}:{node.MoonlightDaemonPort}/";
+        
+        RestRequest request = new(url + resource);
+
+        request.AddHeader("Content-Type", "application/json");
+        request.AddHeader("Accept", "application/json");
+        request.AddHeader("Authorization", node.Token);
+        
+        return Task.FromResult(request);
+    }
 }

Moonlight/App/ApiClients/Daemon/Requests/Mount.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.ApiClients.Daemon.Requests;
+
+public class Mount
+{
+    public string Server { get; set; } = "";
+    public string ServerPath { get; set; } = "";
+    public string Path { get; set; } = "";
+}

Moonlight/App/ApiClients/Daemon/Requests/Unmount.cs

@@ -0,0 +1,6 @@
+namespace Moonlight.App.ApiClients.Daemon.Requests;
+
+public class Unmount
+{
+    public string Path { get; set; } = "";
+}

Moonlight/App/ApiClients/Daemon/Resources/Container.cs

@@ -0,0 +1,10 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class Container
+{
+    public string Name { get; set; } = "";
+    public long Memory { get; set; }
+    public double Cpu { get; set; }
+    public long NetworkIn { get; set; }
+    public long NetworkOut { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/ContainerStats.cs

@@ -1,15 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class ContainerStats
-{
-    public List<Container> Containers { get; set; } = new();
-    
-    public class Container
-    {
-        public string Name { get; set; }
-        public long Memory { get; set; }
-        public double Cpu { get; set; }
-        public long NetworkIn { get; set; }
-        public long NetworkOut { get; set; }
-    }
-}

Moonlight/App/ApiClients/Daemon/Resources/CpuMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class CpuMetrics
+{
+    public string CpuModel { get; set; } = "";
+    public double CpuUsage { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/CpuStats.cs

@@ -1,8 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class CpuStats
-{
-    public double Usage { get; set; }
-    public int Cores { get; set; }
-    public string Model { get; set; } = "";
-}

Moonlight/App/ApiClients/Daemon/Resources/DiskMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class DiskMetrics
+{
+    public long Used { get; set; }
+    public long Total { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/DiskStats.cs

@@ -1,9 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class DiskStats
-{
-    public long FreeBytes { get; set; }
-    public string DriveFormat { get; set; }
-    public string Name { get; set; }
-    public long TotalSize { get; set; }
-}

Moonlight/App/ApiClients/Daemon/Resources/DockerMetrics.cs

@@ -0,0 +1,6 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class DockerMetrics
+{
+    public Container[] Containers { get; set; } = Array.Empty<Container>();
+}

Moonlight/App/ApiClients/Daemon/Resources/MemoryMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class MemoryMetrics
+{
+    public long Used { get; set; }
+    public long Total { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/MemoryStats.cs

@@ -1,15 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class MemoryStats
-{
-    public List<MemoryStick> Sticks { get; set; } = new();
-    public double Free { get; set; }
-    public double Used { get; set; }
-    public double Total { get; set; }
-    
-    public class MemoryStick
-    {
-        public int Size { get; set; }
-        public string Type { get; set; } = "";
-    }
-}

Moonlight/App/ApiClients/Daemon/Resources/SystemMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class SystemMetrics
+{
+    public string OsName { get; set; } = "";
+    public long Uptime { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/ModrinthApiHelper.cs

@@ -0,0 +1,59 @@
+using Logging.Net;
+using Newtonsoft.Json;
+using RestSharp;
+
+namespace Moonlight.App.ApiClients.Modrinth;
+
+public class ModrinthApiHelper
+{
+    private readonly RestClient Client;
+
+    public ModrinthApiHelper()
+    {
+        Client = new();
+        Client.AddDefaultParameter(
+            new HeaderParameter("User-Agent", "Moonlight-Panel/Moonlight (admin@endelon-hosting.de)")
+        );
+    }
+    
+    public async Task<T> Get<T>(string resource)
+    {
+        var request = CreateRequest(resource);
+
+        request.Method = Method.Get;
+
+        var response = await Client.ExecuteAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            if (response.StatusCode != 0)
+            {
+                throw new ModrinthException(
+                    $"An error occured: ({response.StatusCode}) {response.Content}",
+                    (int)response.StatusCode
+                );
+            }
+            else
+            {
+                throw new Exception($"An internal error occured: {response.ErrorMessage}");
+            }
+        }
+
+        return JsonConvert.DeserializeObject<T>(response.Content!)!;
+    }
+    
+    private RestRequest CreateRequest(string resource)
+    {
+        var url = "https://api.modrinth.com/v2/" + resource;
+
+        var request = new RestRequest(url)
+        {
+            Timeout = 60 * 15
+        };
+
+        request.AddHeader("Content-Type", "application/json");
+        request.AddHeader("Accept", "application/json");
+
+        return request;
+    }
+}

Moonlight/App/ApiClients/Modrinth/ModrinthException.cs

@@ -0,0 +1,19 @@
+namespace Moonlight.App.ApiClients.Modrinth;
+
+public class ModrinthException : Exception
+{
+    public int StatusCode { get; set; }
+    
+    public ModrinthException()
+    {
+    }
+
+    public ModrinthException(string message, int statusCode) : base(message)
+    {
+        StatusCode = statusCode;
+    }
+
+    public ModrinthException(string message, Exception inner) : base(message, inner)
+    {
+    }
+}

Moonlight/App/ApiClients/Modrinth/Resources/Pagination.cs

@@ -0,0 +1,14 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class Pagination
+{
+    [JsonProperty("hits")] public Project[] Hits { get; set; }
+
+    [JsonProperty("offset")] public long Offset { get; set; }
+
+    [JsonProperty("limit")] public long Limit { get; set; }
+
+    [JsonProperty("total_hits")] public long TotalHits { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/Resources/Project.cs

@@ -0,0 +1,48 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class Project
+{
+    [JsonProperty("project_id")] public string ProjectId { get; set; }
+
+    [JsonProperty("project_type")] public string ProjectType { get; set; }
+
+    [JsonProperty("slug")] public string Slug { get; set; }
+
+    [JsonProperty("author")] public string Author { get; set; }
+
+    [JsonProperty("title")] public string Title { get; set; }
+
+    [JsonProperty("description")] public string Description { get; set; }
+
+    [JsonProperty("categories")] public string[] Categories { get; set; }
+
+    [JsonProperty("display_categories")] public string[] DisplayCategories { get; set; }
+
+    [JsonProperty("versions")] public string[] Versions { get; set; }
+
+    [JsonProperty("downloads")] public long Downloads { get; set; }
+
+    [JsonProperty("follows")] public long Follows { get; set; }
+
+    [JsonProperty("icon_url")] public string IconUrl { get; set; }
+
+    [JsonProperty("date_created")] public DateTimeOffset DateCreated { get; set; }
+
+    [JsonProperty("date_modified")] public DateTimeOffset DateModified { get; set; }
+
+    [JsonProperty("latest_version")] public string LatestVersion { get; set; }
+
+    [JsonProperty("license")] public string License { get; set; }
+
+    [JsonProperty("client_side")] public string ClientSide { get; set; }
+
+    [JsonProperty("server_side")] public string ServerSide { get; set; }
+
+    [JsonProperty("gallery")] public Uri[] Gallery { get; set; }
+
+    [JsonProperty("featured_gallery")] public Uri FeaturedGallery { get; set; }
+
+    [JsonProperty("color")] public long? Color { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/Resources/Version.cs

@@ -0,0 +1,57 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class Version
+{
+    [JsonProperty("name")]
+    public string Name { get; set; }
+
+    [JsonProperty("version_number")]
+    public string VersionNumber { get; set; }
+
+    [JsonProperty("changelog")]
+    public string Changelog { get; set; }
+
+    [JsonProperty("dependencies")]
+    public object[] Dependencies { get; set; }
+
+    [JsonProperty("game_versions")]
+    public object[] GameVersions { get; set; }
+
+    [JsonProperty("version_type")]
+    public string VersionType { get; set; }
+
+    [JsonProperty("loaders")]
+    public object[] Loaders { get; set; }
+
+    [JsonProperty("featured")]
+    public bool Featured { get; set; }
+
+    [JsonProperty("status")]
+    public string Status { get; set; }
+
+    [JsonProperty("requested_status")]
+    public string RequestedStatus { get; set; }
+
+    [JsonProperty("id")]
+    public string Id { get; set; }
+
+    [JsonProperty("project_id")]
+    public string ProjectId { get; set; }
+
+    [JsonProperty("author_id")]
+    public string AuthorId { get; set; }
+
+    [JsonProperty("date_published")]
+    public DateTime DatePublished { get; set; }
+
+    [JsonProperty("downloads")]
+    public long Downloads { get; set; }
+
+    [JsonProperty("changelog_url")]
+    public object ChangelogUrl { get; set; }
+
+    [JsonProperty("files")]
+    public VersionFile[] Files { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/Resources/VersionFile.cs

@@ -0,0 +1,21 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class VersionFile
+{
+    [JsonProperty("url")]
+    public Uri Url { get; set; }
+
+    [JsonProperty("filename")]
+    public string Filename { get; set; }
+
+    [JsonProperty("primary")]
+    public bool Primary { get; set; }
+
+    [JsonProperty("size")]
+    public long Size { get; set; }
+
+    [JsonProperty("file_type")]
+    public string FileType { get; set; }
+}

Moonlight/App/Database/Entities/Image.cs

@@ -20,4 +20,5 @@ public class Image
     public List<DockerImage> DockerImages { get; set; } = new();
     public List<ImageVariable> Variables { get; set; } = new();
     public string TagsJson { get; set; } = "";
+    public string BackgroundImageUrl { get; set; } = "";
 }

Moonlight/App/Database/Entities/Server.cs

@@ -13,6 +13,8 @@ public class Server
     public string OverrideStartup { get; set; } = "";
     public bool Installing { get; set; } = false;
     public bool Suspended { get; set; } = false;
+    public bool IsArchived { get; set; } = false;
+    public ServerBackup? Archive { get; set; } = null;
 
     public List<ServerVariable> Variables { get; set; } = new();
     public List<ServerBackup> Backups { get; set; } = new();

Moonlight/App/Database/Entities/User.cs

@@ -43,6 +43,7 @@ public class User
     // Date stuff
     public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
     public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
+    public DateTime LastVisitedAt { get; set; } = DateTime.UtcNow;
     
     // Subscriptions
 

Moonlight/App/Database/Migrations/20230609202138_AddBackgroundImageUrlImage.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddBackgroundImageUrlImage : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "BackgroundImageUrl",
+                table: "Images",
+                type: "longtext",
+                nullable: false)
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "BackgroundImageUrl",
+                table: "Images");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230611152138_AddLastVisitedTimestamp.cs

@@ -0,0 +1,30 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddLastVisitedTimestamp : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTime>(
+                name: "LastVisitedAt",
+                table: "Users",
+                type: "datetime(6)",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "LastVisitedAt",
+                table: "Users");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230614010621_AddedServerAchive.cs

@@ -0,0 +1,59 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedServerAchive : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "ArchiveId",
+                table: "Servers",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsArchived",
+                table: "Servers",
+                type: "tinyint(1)",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Servers_ArchiveId",
+                table: "Servers",
+                column: "ArchiveId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Servers_ServerBackups_ArchiveId",
+                table: "Servers",
+                column: "ArchiveId",
+                principalTable: "ServerBackups",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Servers_ServerBackups_ArchiveId",
+                table: "Servers");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Servers_ArchiveId",
+                table: "Servers");
+
+            migrationBuilder.DropColumn(
+                name: "ArchiveId",
+                table: "Servers");
+
+            migrationBuilder.DropColumn(
+                name: "IsArchived",
+                table: "Servers");
+        }
+    }
+}

Moonlight/App/Database/Migrations/DataContextModelSnapshot.cs

@@ -132,6 +132,10 @@ namespace Moonlight.App.Database.Migrations
                     b.Property<int>("Allocations")
                         .HasColumnType("int");
 
+                    b.Property<string>("BackgroundImageUrl")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
                     b.Property<string>("ConfigFiles")
                         .IsRequired()
                         .HasColumnType("longtext");
@@ -492,6 +496,9 @@ namespace Moonlight.App.Database.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("int");
 
+                    b.Property<int?>("ArchiveId")
+                        .HasColumnType("int");
+
                     b.Property<int>("Cpu")
                         .HasColumnType("int");
 
@@ -507,6 +514,9 @@ namespace Moonlight.App.Database.Migrations
                     b.Property<bool>("Installing")
                         .HasColumnType("tinyint(1)");
 
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("tinyint(1)");
+
                     b.Property<bool>("IsCleanupException")
                         .HasColumnType("tinyint(1)");
 
@@ -538,6 +548,8 @@ namespace Moonlight.App.Database.Migrations
 
                     b.HasKey("Id");
 
+                    b.HasIndex("ArchiveId");
+
                     b.HasIndex("ImageId");
 
                     b.HasIndex("MainAllocationId");
@@ -758,6 +770,9 @@ namespace Moonlight.App.Database.Migrations
                         .IsRequired()
                         .HasColumnType("longtext");
 
+                    b.Property<DateTime>("LastVisitedAt")
+                        .HasColumnType("datetime(6)");
+
                     b.Property<string>("Password")
                         .IsRequired()
                         .HasColumnType("longtext");
@@ -928,6 +943,10 @@ namespace Moonlight.App.Database.Migrations
 
             modelBuilder.Entity("Moonlight.App.Database.Entities.Server", b =>
                 {
+                    b.HasOne("Moonlight.App.Database.Entities.ServerBackup", "Archive")
+                        .WithMany()
+                        .HasForeignKey("ArchiveId");
+
                     b.HasOne("Moonlight.App.Database.Entities.Image", "Image")
                         .WithMany()
                         .HasForeignKey("ImageId")
@@ -950,6 +969,8 @@ namespace Moonlight.App.Database.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("Archive");
+
                     b.Navigation("Image");
 
                     b.Navigation("MainAllocation");

Moonlight/App/Diagnostics/HealthChecks/DaemonHealthCheck.cs

@@ -0,0 +1,58 @@
+using System.Diagnostics;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Moonlight.App.Database.Entities;
+using Moonlight.App.Repositories;
+using Moonlight.App.Services;
+
+namespace Moonlight.App.Diagnostics.HealthChecks;
+
+public class DaemonHealthCheck : IHealthCheck
+{
+    private readonly Repository<Node> NodeRepository;
+    private readonly NodeService NodeService;
+
+    public DaemonHealthCheck(Repository<Node> nodeRepository, NodeService nodeService)
+    {
+        NodeRepository = nodeRepository;
+        NodeService = nodeService;
+    }
+
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken())
+    {
+        var nodes = NodeRepository.Get().ToArray();
+        
+        var results = new Dictionary<Node, bool>();
+        var healthCheckData = new Dictionary<string, object>();
+        
+        foreach (var node in nodes)
+        {
+            try
+            {
+                await NodeService.GetCpuMetrics(node);
+                
+                results.Add(node, true);
+            }
+            catch (Exception e)
+            {
+                results.Add(node, false);
+                healthCheckData.Add(node.Name, e.ToStringDemystified());
+            }
+        }
+
+        var offlineNodes = results
+            .Where(x => !x.Value)
+            .ToArray();
+
+        if (offlineNodes.Length == nodes.Length)
+        {
+            return HealthCheckResult.Unhealthy("All node daemons are offline", null, healthCheckData);
+        }
+        
+        if (offlineNodes.Length == 0)
+        {
+            return HealthCheckResult.Healthy("All node daemons are online");
+        }
+            
+        return HealthCheckResult.Degraded($"{offlineNodes.Length} node daemons are offline", null, healthCheckData);
+    }
+}

Moonlight/App/Diagnostics/HealthChecks/DatabaseHealthCheck.cs

@@ -0,0 +1,32 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Moonlight.App.Database;
+
+namespace Moonlight.App.Diagnostics.HealthChecks;
+
+public class DatabaseHealthCheck : IHealthCheck
+{
+    private readonly DataContext DataContext;
+
+    public DatabaseHealthCheck(DataContext dataContext)
+    {
+        DataContext = dataContext;
+    }
+
+    public async Task<HealthCheckResult> CheckHealthAsync(
+        HealthCheckContext context,
+        CancellationToken cancellationToken = new CancellationToken())
+    {
+        try
+        {
+            await DataContext.Database.OpenConnectionAsync(cancellationToken);
+            await DataContext.Database.CloseConnectionAsync();
+            
+            return HealthCheckResult.Healthy("Database is online");
+        }
+        catch (Exception e)
+        {
+            return HealthCheckResult.Unhealthy("Database is offline", e);
+        }
+    }
+}

Moonlight/App/Diagnostics/HealthChecks/NodeHealthCheck.cs

@@ -0,0 +1,58 @@
+using System.Diagnostics;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Moonlight.App.Database.Entities;
+using Moonlight.App.Repositories;
+using Moonlight.App.Services;
+
+namespace Moonlight.App.Diagnostics.HealthChecks;
+
+public class NodeHealthCheck : IHealthCheck
+{
+    private readonly Repository<Node> NodeRepository;
+    private readonly NodeService NodeService;
+
+    public NodeHealthCheck(Repository<Node> nodeRepository, NodeService nodeService)
+    {
+        NodeRepository = nodeRepository;
+        NodeService = nodeService;
+    }
+
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken())
+    {
+        var nodes = NodeRepository.Get().ToArray();
+        
+        var results = new Dictionary<Node, bool>();
+        var healthCheckData = new Dictionary<string, object>();
+        
+        foreach (var node in nodes)
+        {
+            try
+            {
+                await NodeService.GetStatus(node);
+                
+                results.Add(node, true);
+            }
+            catch (Exception e)
+            {
+                results.Add(node, false);
+                healthCheckData.Add(node.Name, e.ToStringDemystified());
+            }
+        }
+
+        var offlineNodes = results
+            .Where(x => !x.Value)
+            .ToArray();
+
+        if (offlineNodes.Length == nodes.Length)
+        {
+            return HealthCheckResult.Unhealthy("All nodes are offline", null, healthCheckData);
+        }
+        
+        if (offlineNodes.Length == 0)
+        {
+            return HealthCheckResult.Healthy("All nodes are online");
+        }
+            
+        return HealthCheckResult.Degraded($"{offlineNodes.Length} nodes are offline", null, healthCheckData);
+    }
+}

Moonlight/App/Events/EventSystem.cs

@@ -5,7 +5,6 @@ namespace Moonlight.App.Events;
 
 public class EventSystem
 {
-    private Dictionary<int, object> Storage = new();
     private List<Subscriber> Subscribers = new();
 
     private readonly bool Debug = false;
@@ -33,16 +32,8 @@ public class EventSystem
         return Task.CompletedTask;
     }
 
-    public Task Emit(string id, object? d = null)
+    public Task Emit(string id, object? data = null)
     {
-        int hashCode = -1;
-
-        if (d != null)
-        {
-            hashCode = d.GetHashCode();
-            Storage.TryAdd(hashCode, d);
-        }
-
         Subscriber[] subscribers;
 
         lock (Subscribers)
@@ -58,23 +49,6 @@ public class EventSystem
         {
             tasks.Add(new Task(() =>
             {
-                int storageId = hashCode + 0; // To create a copy of the hash code
-
-                object? data = null;
-
-                if (storageId != -1)
-                {
-                    if (Storage.TryGetValue(storageId, out var value))
-                    {
-                        data = value;
-                    }
-                    else
-                    {
-                        Logger.Warn($"Object with the hash '{storageId}' was not present in the storage");
-                        return;
-                    }
-                }
-
                 var stopWatch = new Stopwatch();
                 stopWatch.Start();
 
@@ -115,7 +89,6 @@ public class EventSystem
         Task.Run(() =>
         {
             Task.WaitAll(tasks.ToArray());
-            Storage.Remove(hashCode);
 
             if(Debug)
                 Logger.Debug($"Completed all event tasks for '{id}' and removed object from storage");
@@ -139,4 +112,22 @@ public class EventSystem
         
         return Task.CompletedTask;
     }
+    
+    public Task<T> WaitForEvent<T>(string id, object handle, Func<T, bool> filter)
+    {
+        var taskCompletionSource = new TaskCompletionSource<T>();
+    
+        Func<T, Task> action = async data =>
+        {
+            if (filter.Invoke(data))
+            {
+                taskCompletionSource.SetResult(data);
+                await Off(id, handle);
+            }
+        };
+
+        On<T>(id, handle, action);
+
+        return taskCompletionSource.Task;
+    }
 }

Moonlight/App/Exceptions/DisplayException.cs

@@ -5,6 +5,8 @@ namespace Moonlight.App.Exceptions;
 [Serializable]
 public class DisplayException : Exception
 {
+    public bool DoNotTranslate { get; set; } = false;
+    
     //
     // For guidelines regarding the creation of new exception types, see
     //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
@@ -20,6 +22,11 @@ public class DisplayException : Exception
     {
     }
     
+    public DisplayException(string message, bool doNotTranslate) : base(message)
+    {
+        DoNotTranslate = doNotTranslate;
+    }
+
     public DisplayException(string message, Exception inner) : base(message, inner)
     {
     }

Moonlight/App/Helpers/AvgHelper.cs

@@ -0,0 +1,39 @@
+using Moonlight.App.Database.Entities;
+
+namespace Moonlight.App.Helpers;
+
+public static class AvgHelper
+{
+    public static StatisticsData[] Calculate(StatisticsData[] data, int splitSize = 40)
+    {
+        if (data.Length <= splitSize)
+            return data;
+
+        var result = new List<StatisticsData>();
+
+        var i = data.Length / (float)splitSize;
+        var pc = (int)Math.Round(i);
+
+        foreach (var part in data.Chunk(pc))
+        {
+            double d = 0;
+            var res = new StatisticsData();
+
+            foreach (var entry in part)
+            {
+                d += entry.Value;
+            }
+
+            res.Chart = part.First().Chart;
+            res.Date = part.First().Date;
+
+            if (d == 0)
+                res.Value = 0;
+
+            res.Value = d / part.Length;
+            result.Add(res);
+        }
+
+        return result.ToArray();
+    }
+}

Moonlight/App/Helpers/Files/WingsFileAccess.cs

@@ -3,6 +3,7 @@ using Moonlight.App.ApiClients.Wings;
 using Moonlight.App.ApiClients.Wings.Requests;
 using Moonlight.App.ApiClients.Wings.Resources;
 using Moonlight.App.Database.Entities;
+using Moonlight.App.Helpers.Wings;
 using Moonlight.App.Services;
 using RestSharp;
 
@@ -210,6 +211,8 @@ public class WingsFileAccess : FileAccess
     }
 
     public override async Task Decompress(FileData fileData)
+    {
+        try
         {
             var req = new DecompressFile()
             {
@@ -219,6 +222,18 @@ public class WingsFileAccess : FileAccess
 
             await WingsApiHelper.Post(Server.Node, $"api/servers/{Server.Uuid}/files/decompress", req);
         }
+        catch (Exception e)
+        {
+            if (e.Message.ToLower().Contains("canceled"))
+            {
+                // ignore, maybe do smth better here, like showing a waiting thing or so
+            }
+            else
+            {
+                throw;
+            }
+        }
+    }
 
     public override Task<string> GetLaunchUrl()
     {

Moonlight/App/Helpers/Formatter.cs

@@ -8,8 +8,27 @@ public static class Formatter
     {
         TimeSpan t = TimeSpan.FromMilliseconds(uptime);
 
+        if (t.Days > 0)
+        {
+            return $"{t.Days}d  {t.Hours}h {t.Minutes}m {t.Seconds}s";
+        }
+        else
+        {
             return $"{t.Hours}h {t.Minutes}m {t.Seconds}s";
         }
+    }
+    
+    public static string FormatUptime(TimeSpan t)
+    {
+        if (t.Days > 0)
+        {
+            return $"{t.Days}d  {t.Hours}h {t.Minutes}m {t.Seconds}s";
+        }
+        else
+        {
+            return $"{t.Hours}h {t.Minutes}m {t.Seconds}s";
+        }
+    }
 
     private static double Round(this double d, int decimals)
     {
@@ -109,4 +128,12 @@ public static class Formatter
             return (i / (1024D * 1024D)).Round(2) + " GB";
         }
     }
+    
+    public static double BytesToGb(long bytes)
+    {
+        const double gbMultiplier = 1024 * 1024 * 1024; // 1 GB = 1024 MB * 1024 KB * 1024 B
+
+        double gigabytes = (double)bytes / gbMultiplier;
+        return gigabytes;
+    }
 }

Moonlight/App/Helpers/Wings/Data/ConsoleMessage.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Helpers.Wings.Data;
+
+public class ConsoleMessage
+{
+    public string Content { get; set; } = "";
+    public bool IsInternal { get; set; } = false;
+}

Moonlight/App/Helpers/Wings/Data/ServerResource.cs

@@ -0,0 +1,36 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.Helpers.Wings.Data;
+
+public class ServerResource
+{
+    [JsonProperty("memory_bytes")]
+    public long MemoryBytes { get; set; }
+
+    [JsonProperty("memory_limit_bytes")]
+    public long MemoryLimitBytes { get; set; }
+
+    [JsonProperty("cpu_absolute")]
+    public float CpuAbsolute { get; set; }
+
+    [JsonProperty("network")]
+    public NetworkData Network { get; set; }
+
+    [JsonProperty("uptime")]
+    public double Uptime { get; set; }
+
+    [JsonProperty("state")]
+    public string State { get; set; }
+
+    [JsonProperty("disk_bytes")]
+    public long DiskBytes { get; set; }
+
+    public class NetworkData
+    {
+        [JsonProperty("rx_bytes")]
+        public long RxBytes { get; set; }
+
+        [JsonProperty("tx_bytes")]
+        public long TxBytes { get; set; }
+    }
+}

Moonlight/App/Helpers/Wings/Enums/ConsoleState.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.Helpers.Wings.Enums;
+
+public enum ConsoleState
+{
+    Disconnected,
+    Connecting,
+    Connected
+}

Moonlight/App/Helpers/Wings/Enums/ServerState.cs

@@ -0,0 +1,10 @@
+namespace Moonlight.App.Helpers.Wings.Enums;
+
+public enum ServerState
+{
+    Starting,
+    Running,
+    Stopping,
+    Offline,
+    Installing
+}

Moonlight/App/Helpers/Wings/Events/BaseEvent.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Helpers.Wings.Events;
+
+public class BaseEvent
+{
+    public string Event { get; set; } = "";
+    public string[] Args { get; set; } = Array.Empty<string>();
+}

Moonlight/App/Helpers/Wings/Events/SendTokenEvent.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Helpers.Wings.Events;
+
+public class SendTokenEvent
+{
+    public string Event { get; set; } = "auth";
+    public List<string> Args = new();
+}

Moonlight/App/Helpers/Wings/WingsConsole.cs

@@ -0,0 +1,390 @@
+using System.Net.WebSockets;
+using System.Text;
+using Logging.Net;
+using Moonlight.App.Helpers.Wings.Data;
+using Moonlight.App.Helpers.Wings.Enums;
+using Moonlight.App.Helpers.Wings.Events;
+using Newtonsoft.Json;
+using ConsoleMessage = Moonlight.App.Helpers.Wings.Data.ConsoleMessage;
+
+namespace Moonlight.App.Helpers.Wings;
+
+public class WingsConsole : IDisposable
+{
+    private ClientWebSocket WebSocket;
+    public List<ConsoleMessage> Messages;
+    private Task? ConsoleTask;
+
+    private string Socket = "";
+    private string Origin = "";
+    private string Token = "";
+    
+    private bool Disconnecting;
+
+    public ConsoleState ConsoleState { get; private set; }
+    public ServerState ServerState { get; private set; }
+    public ServerResource Resource { get; private set; }
+
+    public EventHandler<ConsoleState> OnConsoleStateUpdated { get; set; }
+    public EventHandler<ServerState> OnServerStateUpdated { get; set; }
+    public EventHandler<ServerResource> OnResourceUpdated { get; set; }
+    public EventHandler<ConsoleMessage> OnMessage { get; set; }
+    public Func<WingsConsole, Task<string>> OnRequestNewToken { get; set; }
+
+    public WingsConsole()
+    {
+        ConsoleState = ConsoleState.Disconnected;
+        ServerState = ServerState.Offline;
+        Messages = new();
+        
+        Resource = new()
+        {
+            Network = new()
+            {
+                RxBytes = 0,
+                TxBytes = 0
+            },
+            State = "offline",
+            Uptime = 0,
+            CpuAbsolute = 0,
+            DiskBytes = 0,
+            MemoryBytes = 0,
+            MemoryLimitBytes = 0
+        };
+    }
+
+    public Task Connect(string origin, string socket, string token)
+    {
+        Disconnecting = false;
+        WebSocket = new();
+        ConsoleState = ConsoleState.Disconnected;
+        ServerState = ServerState.Offline;
+        Messages = new();
+        
+        Resource = new()
+        {
+            Network = new()
+            {
+                RxBytes = 0,
+                TxBytes = 0
+            },
+            State = "offline",
+            Uptime = 0,
+            CpuAbsolute = 0,
+            DiskBytes = 0,
+            MemoryBytes = 0,
+            MemoryLimitBytes = 0
+        };
+        
+        Socket = socket;
+        Origin = origin;
+        Token = token;
+
+        WebSocket.Options.SetRequestHeader("Origin", Origin);
+        WebSocket.Options.SetRequestHeader("Authorization", "Bearer " + Token);
+
+        ConsoleTask = Task.Run(async () =>
+        {
+            try
+            {
+                await Work();
+            }
+            catch (Exception e)
+            {
+                Logger.Warn("Error connecting to wings console");
+                Logger.Warn(e);
+            }
+        });
+
+        return Task.CompletedTask;
+    }
+
+    private async Task Work()
+    {
+        await UpdateConsoleState(ConsoleState.Connecting);
+
+        await WebSocket.ConnectAsync(
+            new Uri(Socket),
+            CancellationToken.None
+        );
+
+        if (WebSocket.State != WebSocketState.Connecting && WebSocket.State != WebSocketState.Open)
+        {
+            await SaveMessage("Unable to connect to websocket", true);
+            await UpdateConsoleState(ConsoleState.Disconnected);
+            return;
+        }
+
+        await UpdateConsoleState(ConsoleState.Connected);
+
+        await Send(new SendTokenEvent()
+        {
+            Args = { Token }
+        });
+
+        while (WebSocket.State == WebSocketState.Open)
+        {
+            try
+            {
+                var raw = await ReceiveRaw();
+                
+                if(string.IsNullOrEmpty(raw))
+                    continue;
+                
+                var eventData = JsonConvert.DeserializeObject<BaseEvent>(raw);
+
+                if (eventData == null)
+                {
+                    await SaveMessage("Unable to parse event", true);
+                    continue;
+                }
+
+                switch (eventData.Event)
+                {
+                    case "jwt error":
+                        if (WebSocket != null)
+                        {
+                            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                                await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None);
+            
+                            WebSocket.Dispose();
+                        }
+                        
+                        await UpdateServerState(ServerState.Offline);
+                        await UpdateConsoleState(ConsoleState.Disconnected);
+
+                        await SaveMessage("Received a jwt error. Disconnected", true);
+                        break;
+
+                    case "token expired":
+                        if (WebSocket != null)
+                        {
+                            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                                await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None);
+            
+                            WebSocket.Dispose();
+                        }
+                        
+                        await UpdateServerState(ServerState.Offline);
+                        await UpdateConsoleState(ConsoleState.Disconnected);
+
+                        await SaveMessage("Token expired", true);
+                        
+                        break;
+
+                    case "token expiring":
+                        await SaveMessage("Token will expire soon. Generating a new one", true);
+
+                        Token = await OnRequestNewToken.Invoke(this);
+
+                        await Send(new SendTokenEvent()
+                        {
+                            Args = { Token }
+                        });
+                        break;
+
+                    case "auth success":
+                        // Send intents
+                        await SendRaw("{\"event\":\"send logs\",\"args\":[null]}");
+                        await SendRaw("{\"event\":\"send stats\",\"args\":[null]}");
+                        break;
+
+                    case "stats":
+                        var stats = JsonConvert.DeserializeObject<ServerResource>(eventData.Args[0]);
+
+                        if (stats == null)
+                            break;
+
+                        var serverState = ParseServerState(stats.State);
+
+                        if (ServerState != serverState)
+                            await UpdateServerState(serverState);
+
+                        await UpdateResource(stats);
+                        break;
+
+                    case "status":
+                        var serverStateParsed = ParseServerState(eventData.Args[0]);
+
+                        if (ServerState != serverStateParsed)
+                            await UpdateServerState(serverStateParsed);
+                        break;
+
+                    case "console output":
+                        foreach (var line in eventData.Args)
+                        {
+                            await SaveMessage(line);
+                        }
+
+                        break;
+
+                    case "install output":
+                        foreach (var line in eventData.Args)
+                        {
+                            await SaveMessage(line);
+                        }
+
+                        break;
+
+                    case "daemon message":
+                        foreach (var line in eventData.Args)
+                        {
+                            await SaveMessage(line);
+                        }
+
+                        break;
+
+                    case "install started":
+                        await UpdateServerState(ServerState.Installing);
+                        break;
+
+                    case "install completed":
+                        await UpdateServerState(ServerState.Offline);
+                        break;
+                }
+            }
+            catch(JsonReaderException){}
+            catch (Exception e)
+            {
+                if (!Disconnecting)
+                {
+                    Logger.Warn("Error while performing websocket actions");
+                    Logger.Warn(e);
+
+                    await SaveMessage("A unknown error occured while processing websocket", true);
+                }
+            }
+        }
+    }
+
+    private Task UpdateConsoleState(ConsoleState consoleState)
+    {
+        ConsoleState = consoleState;
+        OnConsoleStateUpdated?.Invoke(this, consoleState);
+
+        return Task.CompletedTask;
+    }
+    private Task UpdateServerState(ServerState serverState)
+    {
+        ServerState = serverState;
+        OnServerStateUpdated?.Invoke(this, serverState);
+
+        return Task.CompletedTask;
+    }
+    private Task UpdateResource(ServerResource resource)
+    {
+        Resource = resource;
+        OnResourceUpdated?.Invoke(this, Resource);
+
+        return Task.CompletedTask;
+    }
+
+    private Task SaveMessage(string content, bool internalMessage = false)
+    {
+        var msg = new ConsoleMessage()
+        {
+            Content = content,
+            IsInternal = internalMessage
+        };
+
+        lock (Messages)
+        {
+            Messages.Add(msg);
+        }
+
+        OnMessage?.Invoke(this, msg);
+
+        return Task.CompletedTask;
+    }
+    
+    private ServerState ParseServerState(string raw)
+    {
+        switch (raw)
+        {
+            case "offline":
+                return ServerState.Offline;
+            case "starting":
+                return ServerState.Starting;
+            case "running":
+                return ServerState.Running;
+            case "stopping":
+                return ServerState.Stopping;
+            case "installing":
+                return ServerState.Installing;
+            default:
+                return ServerState.Offline;
+        }
+    }
+    
+    public async Task EnterCommand(string content)
+    {
+        if (ConsoleState == ConsoleState.Connected)
+        {
+            await SendRaw("{\"event\":\"send command\",\"args\":[\"" + content + "\"]}");
+        }
+    }
+
+    public async Task SetPowerState(string state)
+    {
+        if (ConsoleState == ConsoleState.Connected)
+        {
+            await SendRaw("{\"event\":\"set state\",\"args\":[\"" + state + "\"]}");
+        }
+    }
+
+    private async Task Send(object data)
+    {
+        await SendRaw(JsonConvert.SerializeObject(data));
+    }
+    
+    private async Task SendRaw(string data)
+    {
+        if (WebSocket.State == WebSocketState.Open)
+        {
+            byte[] byteContentBuffer = Encoding.UTF8.GetBytes(data);
+            await WebSocket.SendAsync(new ArraySegment<byte>(byteContentBuffer), WebSocketMessageType.Text, true,
+                CancellationToken.None);
+        }
+    }
+
+    private async Task<string> ReceiveRaw()
+    {
+        ArraySegment<byte> receivedBytes = new ArraySegment<byte>(new byte[1024]);
+        WebSocketReceiveResult result = await WebSocket.ReceiveAsync(receivedBytes, CancellationToken.None);
+        return Encoding.UTF8.GetString(receivedBytes.Array!, 0, result.Count);
+    }
+
+    public async Task Disconnect()
+    {
+        Disconnecting = true;
+        Messages.Clear();
+
+        if (WebSocket != null)
+        {
+            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None);
+            
+            WebSocket.Dispose();
+        }
+
+        if(ConsoleTask != null && ConsoleTask.IsCompleted)
+            ConsoleTask.Dispose();
+    }
+
+    public void Dispose()
+    {
+        Disconnecting = true;
+        Messages.Clear();
+
+        if (WebSocket != null)
+        {
+            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None).Wait();
+            
+            WebSocket.Dispose();
+        }
+        
+        if(ConsoleTask != null && ConsoleTask.IsCompleted)
+            ConsoleTask.Dispose();
+    }
+}

Moonlight/App/Helpers/Wings/WingsConsoleHelper.cs

@@ -7,37 +7,34 @@ using Moonlight.App.Database.Entities;
 using Moonlight.App.Repositories.Servers;
 using Moonlight.App.Services;
 
-namespace Moonlight.App.Helpers;
+namespace Moonlight.App.Helpers.Wings;
 
 public class WingsConsoleHelper
 {
     private readonly ServerRepository ServerRepository;
-    private readonly WingsJwtHelper WingsJwtHelper;
     private readonly string AppUrl;
 
     public WingsConsoleHelper(
         ServerRepository serverRepository,
-        ConfigService configService,
-        WingsJwtHelper wingsJwtHelper)
+        ConfigService configService)
     {
         ServerRepository = serverRepository;
-        WingsJwtHelper = wingsJwtHelper;
 
         AppUrl = configService.GetSection("Moonlight").GetValue<string>("AppUrl");
     }
 
-    public async Task ConnectWings(PteroConsole.NET.PteroConsole pteroConsole, Server server)
+    public async Task ConnectWings(WingsConsole console, Server server)
     {
         var serverData = ServerRepository
             .Get()
             .Include(x => x.Node)
             .First(x => x.Id == server.Id);
         
-        var token = GenerateToken(serverData);
+        var token = await GenerateToken(serverData);
 
         if (serverData.Node.Ssl)
         {
-            await pteroConsole.Connect(
+            await console.Connect(
                 AppUrl,
                 $"wss://{serverData.Node.Fqdn}:{serverData.Node.HttpPort}/api/servers/{serverData.Uuid}/ws",
                 token
@@ -45,7 +42,7 @@ public class WingsConsoleHelper
         }
         else
         {
-            await pteroConsole.Connect(
+            await console.Connect(
                 AppUrl,
                 $"ws://{serverData.Node.Fqdn}:{serverData.Node.HttpPort}/api/servers/{serverData.Uuid}/ws",
                 token
@@ -53,7 +50,7 @@ public class WingsConsoleHelper
         }
     }
 
-    public string GenerateToken(Server server)
+    public async Task<string> GenerateToken(Server server)
     {
         var serverData = ServerRepository
             .Get()
@@ -66,7 +63,7 @@ public class WingsConsoleHelper
 
         using (MD5 md5 = MD5.Create())
         {
-            var inputBytes = Encoding.ASCII.GetBytes(userid + serverData.Uuid.ToString());
+            var inputBytes = Encoding.ASCII.GetBytes(userid + server.Uuid.ToString());
             var outputBytes = md5.ComputeHash(inputBytes);
 
             var identifier = Convert.ToHexString(outputBytes).ToLower();
@@ -77,7 +74,7 @@ public class WingsConsoleHelper
                 .WithAlgorithm(new HMACSHA256Algorithm())
                 .WithSecret(secret)
                 .AddClaim("user_id", userid)
-                .AddClaim("server_uuid", serverData.Uuid.ToString())
+                .AddClaim("server_uuid", server.Uuid.ToString())
                 .AddClaim("permissions", new[]
                 {
                     "*",

Moonlight/App/Helpers/Wings/WingsJwtHelper.cs

@@ -4,7 +4,7 @@ using JWT.Algorithms;
 using JWT.Builder;
 using Moonlight.App.Services;
 
-namespace Moonlight.App.Helpers;
+namespace Moonlight.App.Helpers.Wings;
 
 public class WingsJwtHelper
 {

Moonlight/App/Helpers/Wings/WingsServerConverter.cs

@@ -5,7 +5,7 @@ using Moonlight.App.Http.Resources.Wings;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;
 
-namespace Moonlight.App.Helpers;
+namespace Moonlight.App.Helpers.Wings;
 
 public class WingsServerConverter
 {

Moonlight/App/Http/Controllers/Api/Moonlight/DiscordBotController.cs

@@ -102,7 +102,7 @@ public class DiscordBotController : Controller
             return BadRequest();
     }
 
-    [HttpGet("{id}/servers/{uuid}")]
+    [HttpGet("{id}/servers/{uuid}/details")]
     public async Task<ActionResult<ServerDetails>> GetServerDetails(ulong id, Guid uuid)
     {
         if (!await IsAuth(Request))
@@ -124,6 +124,33 @@ public class DiscordBotController : Controller
         return await ServerService.GetDetails(server);
     }
     
+    [HttpGet("{id}/servers/{uuid}")]
+    public async Task<ActionResult<ServerDetails>> GetServer(ulong id, Guid uuid)
+    {
+        if (!await IsAuth(Request))
+            return StatusCode(403);
+        
+        var user = await GetUserFromDiscordId(id);
+
+        if (user == null)
+            return BadRequest();
+
+        var server = ServerRepository
+            .Get()
+            .Include(x => x.Owner)
+            .Include(x => x.Image)
+            .Include(x => x.Node)
+            .FirstOrDefault(x => x.Owner.Id == user.Id && x.Uuid == uuid);
+
+        if (server == null)
+            return NotFound();
+
+        server.Node.Token = "";
+        server.Node.TokenId = "";
+
+        return Ok(server);
+    }
+
     private Task<User?> GetUserFromDiscordId(ulong discordId)
     {
         var user = UserRepository

Moonlight/App/Http/Controllers/Api/Moonlight/Notifications/ListenController.cs

@@ -1,7 +1,9 @@
 using System.Net.WebSockets;
 using System.Text;
+using Logging.Net;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
+using Moonlight.App.Database.Entities;
 using Moonlight.App.Database.Entities.Notification;
 using Moonlight.App.Models.Notifications;
 using Moonlight.App.Repositories;
@@ -12,135 +14,156 @@ using Newtonsoft.Json;
 
 namespace Moonlight.App.Http.Controllers.Api.Moonlight.Notifications;
 
-public class ListenController : ControllerBase
+[ApiController]
+[Route("api/moonlight/notification/listen")]
+public class ListenController : Controller
 {
-    internal WebSocket ws;
-    private bool active = true;
-    private bool isAuth = false;
+    private WebSocket WebSocket;
     private NotificationClient Client;
+    private CancellationTokenSource CancellationTokenSource = new();
+
+    private User? CurrentUser;
 
-    private readonly IdentityService IdentityService;
-    private readonly NotificationRepository NotificationRepository;
     private readonly OneTimeJwtService OneTimeJwtService;
-    private readonly NotificationClientService NotificationClientService;
     private readonly NotificationServerService NotificationServerService;
+    private readonly Repository<NotificationClient> NotificationClientRepository;
 
-    public ListenController(IdentityService identityService, 
-        NotificationRepository notificationRepository, 
+    public ListenController(
         OneTimeJwtService oneTimeJwtService,
-        NotificationClientService notificationClientService,
-        NotificationServerService notificationServerService)
+        NotificationServerService notificationServerService, Repository<NotificationClient> notificationClientRepository)
     {
-        IdentityService = identityService;
-        NotificationRepository = notificationRepository;
         OneTimeJwtService = oneTimeJwtService;
-        NotificationClientService = notificationClientService;
         NotificationServerService = notificationServerService;
+        NotificationClientRepository = notificationClientRepository;
     }
 
     [Route("/api/moonlight/notifications/listen")]
-    public async Task Get()
+    public async Task<ActionResult> Get()
     {
         if (HttpContext.WebSockets.IsWebSocketRequest)
         {
-            using var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
-            ws = webSocket;
-            await Echo();
+            WebSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
+
+            await ProcessWebsocket();
+
+            return new EmptyResult();
         }
         else
         {
-            HttpContext.Response.StatusCode = StatusCodes.Status403Forbidden;
+            return StatusCode(400);
         }
     }
 
-    private async Task Echo()
+    private async Task ProcessWebsocket()
     {
-        while (active)
+        while (!CancellationTokenSource.Token.IsCancellationRequested && WebSocket.State == WebSocketState.Open)
         {
-            byte[] bytes = new byte[1024 * 16]; 
-            var asg = new ArraySegment<byte>(bytes);
-            var res = await ws.ReceiveAsync(asg, CancellationToken.None);
-
-            var text = Encoding.UTF8.GetString(bytes).Trim('\0');
-
-            var obj = JsonConvert.DeserializeObject<BasicWSModel>(text);
-
-            if (!string.IsNullOrWhiteSpace(obj.Action))
+            try
             {
-                await HandleRequest(text, obj.Action);
+                byte[] buffer = new byte[1024 * 16];
+                _ = await WebSocket.ReceiveAsync(buffer, CancellationTokenSource.Token);
+                var text = Encoding.UTF8.GetString(buffer).Trim('\0');
+
+                var basicWsModel = JsonConvert.DeserializeObject<BasicWSModel>(text) ?? new();
+
+                if (!string.IsNullOrWhiteSpace(basicWsModel.Action))
+                {
+                    await HandleRequest(text, basicWsModel.Action);
                 }
 
-            active = ws.State == WebSocketState.Open;
+                if (WebSocket.State != WebSocketState.Open)
+                {
+                    CancellationTokenSource.Cancel();
                 }
             }
+            catch (WebSocketException e)
+            {
+                CancellationTokenSource.Cancel();
+            }
+        }
+
+        await NotificationServerService.UnRegisterClient(Client);
+    }
 
     private async Task HandleRequest(string text, string action)
     {
-        if (!isAuth && action == "login")
-            await Login(text);
-        else if (!isAuth)
-            await ws.SendAsync(Encoding.UTF8.GetBytes("{\"error\": \"Unauthorised\"}"), WebSocketMessageType.Text,
-                WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
-        else switch (action)
+        if (CurrentUser == null && action != "login")
         {
+            await Send("{\"error\": \"Unauthorised\"}");
+        }
+
+        switch (action)
+        {
+            case "login":
+                await Login(text);
+                break;
             case "received":
                 await Received(text);
                 break;
             case "read":
                 await Read(text);
                 break;
-            default:
-                break;
         }
     }
 
+    private async Task Send(string text)
+    {
+        await WebSocket.SendAsync(
+            Encoding.UTF8.GetBytes(text),
+            WebSocketMessageType.Text,
+            WebSocketMessageFlags.EndOfMessage, CancellationTokenSource.Token
+        );
+    }
+
     private async Task Login(string json)
     {
-        var jwt = JsonConvert.DeserializeObject<Login>(json).token;
+        var loginModel = JsonConvert.DeserializeObject<Login>(json) ?? new();
 
-        var dict = await OneTimeJwtService.Validate(jwt);
+        var dict = await OneTimeJwtService.Validate(loginModel.Token);
 
         if (dict == null)
         {
-            string error = "{\"status\":false}";
-            var bytes = Encoding.UTF8.GetBytes(error);
-            await ws.SendAsync(bytes, WebSocketMessageType.Text, WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
+            await Send("{\"status\":false}");
             return;
         }
 
-        var _clientId = dict["clientId"];
-        var clientId = int.Parse(_clientId);
-
-        var client = NotificationRepository.GetClients().Include(x => x.User).First(x => x.Id == clientId);
-
-        Client = client;
-        await InitWebsocket();
-        
-        string success = "{\"status\":true}";
-        var byt = Encoding.UTF8.GetBytes(success);
-        await ws.SendAsync(byt, WebSocketMessageType.Text, WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
+        if (!int.TryParse(dict["clientId"], out int clientId))
+        {
+            await Send("{\"status\":false}");
+            return;
         }
 
-    private async Task InitWebsocket()
-    {
-        NotificationClientService.listenController = this;
-        NotificationClientService.WebsocketReady(Client);
+        Client = NotificationClientRepository
+            .Get()
+            .Include(x => x.User)
+            .First(x => x.Id == clientId);
 
-        isAuth = true;
+        CurrentUser = Client.User;
+
+        await NotificationServerService.RegisterClient(WebSocket, Client);
+
+        await Send("{\"status\":true}");
     }
 
     private async Task Received(string json)
     {
-        var id = JsonConvert.DeserializeObject<NotificationById>(json).notification;
+        var id = JsonConvert.DeserializeObject<NotificationById>(json).Notification;
 
         //TODO: Implement ws notification received
     }
 
     private async Task Read(string json)
     {
-        var id = JsonConvert.DeserializeObject<NotificationById>(json).notification;
+        var model = JsonConvert.DeserializeObject<NotificationById>(json) ?? new();
 
-        await NotificationServerService.SendAction(NotificationClientService.User,
-            JsonConvert.SerializeObject(new NotificationById() {Action = "hide", notification = id}));
+        await NotificationServerService.SendAction(
+            CurrentUser!,
+            JsonConvert.SerializeObject(
+                new NotificationById()
+                {
+                    Action = "hide", Notification = model.Notification
+                }
+            )
+        );
     }
 }

Moonlight/App/Http/Controllers/Api/Moonlight/OAuth2Controller.cs

@@ -1,6 +1,7 @@
 using Logging.Net;
 using Microsoft.AspNetCore.Mvc;
 using Moonlight.App.Services;
+using Moonlight.App.Services.Sessions;
 
 namespace Moonlight.App.Http.Controllers.Api.Moonlight;
 
@@ -11,12 +12,41 @@ public class OAuth2Controller : Controller
     private readonly UserService UserService;
     private readonly OAuth2Service OAuth2Service;
     private readonly DateTimeService DateTimeService;
+    private readonly IdentityService IdentityService;
 
-    public OAuth2Controller(UserService userService, OAuth2Service oAuth2Service, DateTimeService dateTimeService)
+    public OAuth2Controller(
+        UserService userService,
+        OAuth2Service oAuth2Service,
+        DateTimeService dateTimeService,
+        IdentityService identityService)
     {
         UserService = userService;
         OAuth2Service = oAuth2Service;
         DateTimeService = dateTimeService;
+        IdentityService = identityService;
+    }
+
+    [HttpGet("{id}/start")]
+    public async Task<ActionResult> Start([FromRoute] string id)
+    {
+        try
+        {
+            if (OAuth2Service.Providers.ContainsKey(id))
+            {
+                return Redirect(await OAuth2Service.GetUrl(id));
+            }
+            
+            Logger.Warn($"Someone tried to start an oauth2 flow using the id '{id}' which is not registered");
+
+            return Redirect("/");
+        }
+        catch (Exception e)
+        {
+            Logger.Warn($"Error starting oauth2 flow for id: {id}");
+            Logger.Warn(e);
+            
+            return Redirect("/");
+        }
     }
 
     [HttpGet("{id}")]
@@ -24,6 +54,18 @@ public class OAuth2Controller : Controller
     {
         try
         {
+            var currentUser = await IdentityService.Get();
+
+            if (currentUser != null)
+            {
+                if (await OAuth2Service.CanBeLinked(id))
+                {
+                    await OAuth2Service.LinkToUser(id, currentUser, code);
+                    
+                    return Redirect("/profile");
+                }
+            }
+            
             var user = await OAuth2Service.HandleCode(id, code);
 
             Response.Cookies.Append("token", await UserService.GenerateToken(user), new()

Moonlight/App/Http/Controllers/Api/Moonlight/ResourcesController.cs

@@ -16,14 +16,12 @@ public class ResourcesController : Controller
 {
     private readonly SecurityLogService SecurityLogService;
     private readonly BucketService BucketService;
-    private readonly BundleService BundleService;
 
     public ResourcesController(SecurityLogService securityLogService,
-        BucketService bucketService, BundleService bundleService)
+        BucketService bucketService)
     {
         SecurityLogService = securityLogService;
         BucketService = bucketService;
-        BundleService = bundleService;
     }
 
     [HttpGet("images/{name}")]
@@ -49,6 +47,29 @@ public class ResourcesController : Controller
         return NotFound();
     }
     
+    [HttpGet("background/{name}")]
+    public async Task<ActionResult> GetBackground([FromRoute] string name)
+    {
+        if (name.Contains(".."))
+        {
+            await SecurityLogService.Log(SecurityLogType.PathTransversal, x =>
+            {
+                x.Add<string>(name);
+            });
+            
+            return NotFound();
+        }
+
+        if (System.IO.File.Exists(PathBuilder.File("storage", "resources", "public", "background", name)))
+        {
+            var fs = new FileStream(PathBuilder.File("storage", "resources", "public", "background", name), FileMode.Open);
+        
+            return File(fs, MimeTypes.GetMimeType(name), name);
+        }
+
+        return NotFound();
+    }
+
     [HttpGet("bucket/{bucket}/{name}")]
     public async Task<ActionResult> GetBucket([FromRoute] string bucket, [FromRoute] string name)
     {
@@ -77,34 +98,4 @@ public class ResourcesController : Controller
             return Problem();
         }
     }
-
-    [HttpGet("bundle/js")]
-    public Task<ActionResult> GetJs()
-    {
-        if (BundleService.BundledFinished)
-        {
-            return Task.FromResult<ActionResult>(
-                File(Encoding.ASCII.GetBytes(BundleService.BundledJs), "text/javascript")
-            );
-        }
-
-        return Task.FromResult<ActionResult>(
-            NotFound()
-        );
-    }
-    
-    [HttpGet("bundle/css")]
-    public Task<ActionResult> GetCss()
-    {
-        if (BundleService.BundledFinished)
-        {
-            return Task.FromResult<ActionResult>(
-                File(Encoding.ASCII.GetBytes(BundleService.BundledCss), "text/css")
-            );
-        }
-
-        return Task.FromResult<ActionResult>(
-            NotFound()
-        );
-    }
 }

Moonlight/App/Http/Controllers/Api/Remote/ServersController.cs

@@ -2,6 +2,7 @@
 using Microsoft.EntityFrameworkCore;
 using Moonlight.App.Events;
 using Moonlight.App.Helpers;
+using Moonlight.App.Helpers.Wings;
 using Moonlight.App.Http.Resources.Wings;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;

Moonlight/App/Models/Forms/ServerImageDataModel.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.Models.Forms;
+
+public class ServerImageDataModel
+{
+    public string OverrideStartup { get; set; }
+    
+    public int DockerImageIndex { get; set; }
+}

Moonlight/App/Models/Forms/ServerOverviewDataModel.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+using Moonlight.App.Database.Entities;
+
+namespace Moonlight.App.Models.Forms;
+
+public class ServerOverviewDataModel
+{
+    [Required(ErrorMessage = "You need to enter a name")]
+    [MaxLength(32, ErrorMessage = "The name cannot be longer that 32 characters")]
+    public string Name { get; set; }
+    
+    [Required(ErrorMessage = "You need to specify a owner")]
+    public User Owner { get; set; }
+}

Moonlight/App/Models/Forms/ServerResourcesDataModel.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Moonlight.App.Models.Forms;
+
+public class ServerResourcesDataModel
+{
+    [Required(ErrorMessage = "You need to specify the cpu cores")]
+    public int Cpu { get; set; }
+    
+    [Required(ErrorMessage = "You need to specify the memory")]
+    public long Memory { get; set; }
+    
+    [Required(ErrorMessage = "You need to specify the disk")]
+    public long Disk { get; set; }
+}

Moonlight/App/Models/Misc/ActiveNotificationClient.cs

@@ -0,0 +1,19 @@
+using System.Net.WebSockets;
+using System.Text;
+using Moonlight.App.Database.Entities.Notification;
+
+namespace Moonlight.App.Models.Misc;
+
+public class ActiveNotificationClient
+{
+    public WebSocket WebSocket { get; set; }
+    public NotificationClient Client { get; set; }
+    
+    public async Task SendAction(string action)
+    {
+        await WebSocket.SendAsync(
+            Encoding.UTF8.GetBytes(action),
+            WebSocketMessageType.Text,
+            WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
+    }
+}

Moonlight/App/Models/Misc/HealthCheck.cs

@@ -0,0 +1,19 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.Models.Misc;
+
+public class HealthCheck
+{
+    public string Status { get; set; }
+    public TimeSpan TotalDuration { get; set; }
+    public Dictionary<string, HealthCheckEntry> Entries { get; set; } = new();
+    
+    public class HealthCheckEntry
+    {
+        public Dictionary<string, string> Data { get; set; } = new();
+        public string Description { get; set; }
+        public TimeSpan Duration { get; set; }
+        public string Status { get; set; }
+        public List<string> Tags { get; set; } = new();
+    }
+}

Moonlight/App/Models/Misc/RunningServer.cs

@@ -6,5 +6,5 @@ namespace Moonlight.App.Models.Misc;
 public class RunningServer
 {
     public Server Server { get; set; }
-    public ContainerStats.Container Container { get; set; }
+    public Container Container { get; set; }
 }

Moonlight/App/Models/Notifications/Login.cs

@@ -1,6 +1,8 @@
-namespace Moonlight.App.Models.Notifications;
+using Newtonsoft.Json;
+
+namespace Moonlight.App.Models.Notifications;
 
 public class Login : BasicWSModel
 {
-    public string token { get; set; }
+    [JsonProperty("token")] public string Token { get; set; } = "";
 }

Moonlight/App/Models/Notifications/NotificationById.cs

@@ -1,6 +1,9 @@
-namespace Moonlight.App.Models.Notifications;
+using Newtonsoft.Json;
+
+namespace Moonlight.App.Models.Notifications;
 
 public class NotificationById : BasicWSModel
 {
-    public int notification { get; set; }
+    [JsonProperty("notification")]
+    public int Notification { get; set; }
 }

Moonlight/App/OAuth2/OAuth2Provider.cs

@@ -9,7 +9,9 @@ public abstract class OAuth2Provider
     public string Url { get; set; }
     public IServiceScopeFactory ServiceScopeFactory { get; set; }
     public string DisplayName { get; set; }
+    public bool CanBeLinked { get; set; } = false;
     
     public abstract Task<string> GetUrl();
     public abstract Task<User> HandleCode(string code);
+    public abstract Task LinkToUser(User user, string code);
 }

Moonlight/App/OAuth2/Providers/DiscordOAuth2Provider.cs

@@ -12,6 +12,11 @@ namespace Moonlight.App.OAuth2.Providers;
 
 public class DiscordOAuth2Provider : OAuth2Provider
 {
+    public DiscordOAuth2Provider()
+    {
+        CanBeLinked = true;
+    }
+    
     public override Task<string> GetUrl()
     {
         string url = $"https://discord.com/api/oauth2/authorize?client_id={Config.ClientId}" +
@@ -119,4 +124,74 @@ public class DiscordOAuth2Provider : OAuth2Provider
             return user;
         }
     }
+
+    public override async Task LinkToUser(User user, string code)
+    {
+        // Endpoints
+        
+        var endpoint = Url + "/api/moonlight/oauth2/discord";
+        var discordUserDataEndpoint = "https://discordapp.com/api/users/@me";
+        var discordEndpoint = "https://discordapp.com/api/oauth2/token";
+
+        // Generate access token
+        
+        using var client = new RestClient();
+        var request = new RestRequest(discordEndpoint);
+
+        request.AddParameter("client_id", Config.ClientId);
+        request.AddParameter("client_secret", Config.ClientSecret);
+        request.AddParameter("grant_type", "authorization_code");
+        request.AddParameter("code", code);
+        request.AddParameter("redirect_uri", endpoint);
+        
+        var response = await client.ExecutePostAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            Logger.Warn("Error verifying oauth2 code");
+            Logger.Warn(response.ErrorMessage);
+            throw new DisplayException("An error occured while verifying oauth2 code");
+        }
+        
+        // parse response
+        
+        var data = new ConfigurationBuilder().AddJsonStream(
+            new MemoryStream(Encoding.ASCII.GetBytes(response.Content!))
+        ).Build();
+
+        var accessToken = data.GetValue<string>("access_token");
+        
+        // Now, we will call the discord api with our access token to get the data we need
+
+        var getRequest = new RestRequest(discordUserDataEndpoint);
+        getRequest.AddHeader("Authorization", $"Bearer {accessToken}");
+
+        var getResponse = await client.ExecuteGetAsync(getRequest);
+        
+        if (!getResponse.IsSuccessful)
+        {
+            Logger.Warn("An unexpected error occured while fetching user data from remote api");
+            Logger.Warn(getResponse.ErrorMessage);
+            
+            throw new DisplayException("An unexpected error occured while fetching user data from remote api");
+        }
+        
+        // Parse response
+        
+        var getData = new ConfigurationBuilder().AddJsonStream(
+            new MemoryStream(Encoding.ASCII.GetBytes(getResponse.Content!))
+        ).Build();
+
+        var id = getData.GetValue<ulong>("id");
+        
+        // Handle data
+        
+        using var scope = ServiceScopeFactory.CreateScope();
+        
+        var userRepo = scope.ServiceProvider.GetRequiredService<Repository<User>>();
+
+        user.DiscordId = id;
+        
+        userRepo.Update(user);
+    }
 }

Moonlight/App/OAuth2/Providers/GoogleOAuth2Provider.cs

@@ -4,7 +4,6 @@ using Moonlight.App.ApiClients.Google.Requests;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Exceptions;
 using Moonlight.App.Helpers;
-using Moonlight.App.Models.Misc;
 using Moonlight.App.Repositories;
 using Moonlight.App.Services;
 using RestSharp;
@@ -13,6 +12,11 @@ namespace Moonlight.App.OAuth2.Providers;
 
 public class GoogleOAuth2Provider : OAuth2Provider
 {
+    public GoogleOAuth2Provider()
+    {
+        CanBeLinked = false;
+    }
+    
     public override Task<string> GetUrl()
     {
         var endpoint = Url + "/api/moonlight/oauth2/google";
@@ -127,4 +131,9 @@ public class GoogleOAuth2Provider : OAuth2Provider
             return user;
         }
     }
+
+    public override Task LinkToUser(User user, string code)
+    {
+        throw new NotImplementedException();
+    }
 }

Moonlight/App/Services/Addon/ServerAddonPluginService.cs

@@ -0,0 +1,83 @@
+using Moonlight.App.ApiClients.Modrinth;
+using Moonlight.App.ApiClients.Modrinth.Resources;
+using Moonlight.App.Exceptions;
+using FileAccess = Moonlight.App.Helpers.Files.FileAccess;
+using Version = Moonlight.App.ApiClients.Modrinth.Resources.Version;
+
+namespace Moonlight.App.Services.Addon;
+
+public class ServerAddonPluginService
+{
+    private readonly ModrinthApiHelper ModrinthApiHelper;
+    private readonly ServerService ServerService;
+
+    public ServerAddonPluginService(ModrinthApiHelper modrinthApiHelper)
+    {
+        ModrinthApiHelper = modrinthApiHelper;
+    }
+
+    public async Task<Project[]> GetPluginsForVersion(string version, string search = "")
+    {
+        string resource;
+        var filter =
+            "[[\"categories:\'bukkit\'\",\"categories:\'paper\'\",\"categories:\'spigot\'\"],[\"versions:" + version + "\"],[\"project_type:mod\"]]";
+
+        if (string.IsNullOrEmpty(search))
+            resource = "search?limit=21&index=relevance&facets=" + filter;
+        else
+            resource = $"search?query={search}&limit=21&index=relevance&facets=" + filter;
+        
+        var result = await ModrinthApiHelper.Get<Pagination>(resource);
+
+        return result.Hits;
+    }
+
+    public async Task InstallPlugin(FileAccess fileAccess, string version, Project project, Action<string>? onStateUpdated = null)
+    {
+        // Resolve plugin download
+        
+        onStateUpdated?.Invoke($"Resolving {project.Slug}");
+        
+        var filter = "game_versions=[\"" + version + "\"]&loaders=[\"bukkit\", \"paper\", \"spigot\"]";
+        
+        var versions = await ModrinthApiHelper.Get<Version[]>(
+            $"project/{project.Slug}/version?" + filter);
+
+        if (!versions.Any())
+            throw new DisplayException("No plugin download for your minecraft version found");
+
+        var installVersion = versions.OrderByDescending(x => x.DatePublished).First();
+        var fileToInstall = installVersion.Files.First();
+        
+        // Download plugin in a stream cached mode
+
+        var httpClient = new HttpClient();
+        var stream = await httpClient.GetStreamAsync(fileToInstall.Url);
+        var dataStream = new MemoryStream(1024 * 1024 * 40);
+        await stream.CopyToAsync(dataStream);
+        stream.Close();
+        dataStream.Position = 0;
+        
+        // Install plugin
+
+        await fileAccess.SetDir("/");
+        
+        try
+        {
+            await fileAccess.MkDir("plugins");
+        }
+        catch (Exception)
+        {
+            // Ignored
+        }
+
+        await fileAccess.SetDir("plugins");
+        
+        onStateUpdated?.Invoke($"Installing {project.Slug}");
+        await fileAccess.Upload(fileToInstall.Filename, dataStream);
+        
+        await dataStream.DisposeAsync();
+        
+        //TODO: At some point of time, create a dependency resolver
+    }
+}

Moonlight/App/Services/Background/CleanupService.cs

@@ -5,6 +5,7 @@ using Moonlight.App.ApiClients.Daemon.Resources;
 using Moonlight.App.ApiClients.Wings;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Events;
+using Moonlight.App.Helpers;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;
 using Newtonsoft.Json;
@@ -81,12 +82,35 @@ public class CleanupService
             {
                 try
                 {
-                    var cpuStats = await nodeService.GetCpuStats(node);
-                    var memoryStats = await nodeService.GetMemoryStats(node);
+                    var cpuMetrics = await nodeService.GetCpuMetrics(node);
+                    var memoryMetrics = await nodeService.GetMemoryMetrics(node);
 
-                    if (cpuStats.Usage > maxCpu || memoryStats.Free < minMemory)
+                    bool executeCleanup;
+                    
+                    if (cpuMetrics.CpuUsage > maxCpu)
                     {
-                        var containerStats = await nodeService.GetContainerStats(node);
+                        Logger.Debug($"{node.Name}: CPU Usage is too high");
+                        Logger.Debug($"Usage:  {cpuMetrics.CpuUsage}");
+                        Logger.Debug($"Max CPU:  {maxCpu}");
+                        executeCleanup = true;
+                    }
+                    else if (Formatter.BytesToGb(memoryMetrics.Total) - Formatter.BytesToGb(memoryMetrics.Used) <
+                             minMemory / 1024D)
+                    {
+                        Logger.Debug($"{node.Name}: Memory Usage is too high");
+                        Logger.Debug($"Memory (Total):  {Formatter.BytesToGb(memoryMetrics.Total)}");
+                        Logger.Debug($"Memory (Used):  {Formatter.BytesToGb(memoryMetrics.Used)}");
+                        Logger.Debug(
+                            $"Memory (Free):  {Formatter.BytesToGb(memoryMetrics.Total) - Formatter.BytesToGb(memoryMetrics.Used)}");
+                        Logger.Debug($"Min Memory:  {minMemory}");
+                        executeCleanup = true;
+                    }
+                    else
+                        executeCleanup = false;
+                    
+                    if (executeCleanup)
+                    {
+                        var dockerMetrics = await nodeService.GetDockerMetrics(node);
 
                         var serverRepository = scope.ServiceProvider.GetRequiredService<ServerRepository>();
                         var imageRepository = scope.ServiceProvider.GetRequiredService<ImageRepository>();
@@ -101,9 +125,9 @@ public class CleanupService
                             )
                             .ToArray();
                         
-                        var containerMappedToServers = new Dictionary<ContainerStats.Container, Server>();
+                        var containerMappedToServers = new Dictionary<Container, Server>();
 
-                        foreach (var container in containerStats.Containers)
+                        foreach (var container in dockerMetrics.Containers)
                         {
                             if (Guid.TryParse(container.Name, out Guid uuid))
                             {
@@ -139,6 +163,7 @@ public class CleanupService
 
                                         if (players == 0)
                                         {
+                                            Logger.Debug($"Restarted {server.Name} ({server.Uuid}) on node {node.Name}");
                                             await serverService.SetPowerState(server, PowerSignal.Restart);
                                             
                                             ServersCleaned++;
@@ -164,10 +189,12 @@ public class CleanupService
 
                                             if (handleJ2S)
                                             {
+                                                Logger.Debug($"Restarted (cleanup) {server.Name} ({server.Uuid}) on node {node.Name}");
                                                 await serverService.SetPowerState(server, PowerSignal.Restart);
                                             }
                                             else
                                             {
+                                                Logger.Debug($"Stopped {server.Name} ({server.Uuid}) on node {node.Name}");
                                                 await serverService.SetPowerState(server, PowerSignal.Stop);
                                             }
 

Moonlight/App/Services/Files/ResourceService.cs

@@ -16,6 +16,11 @@ public class ResourceService
         return $"{AppUrl}/api/moonlight/resources/images/{name}";
     }
     
+    public string BackgroundImage(string name)
+    {
+        return $"{AppUrl}/api/moonlight/resources/background/{name}";
+    }
+
     public string Avatar(User user)
     {
         return $"{AppUrl}/api/moonlight/avatar/{user.Id}";

Moonlight/App/Services/MoonlightService.cs

@@ -0,0 +1,98 @@
+using Logging.Net;
+using Octokit;
+using Repository = LibGit2Sharp.Repository;
+
+namespace Moonlight.App.Services;
+
+public class MoonlightService
+{
+    private readonly ConfigService ConfigService;
+    public readonly DateTime StartTimestamp;
+    public readonly string AppVersion;
+    public readonly List<string[]> ChangeLog = new();
+
+    public MoonlightService(ConfigService configService)
+    {
+        ConfigService = configService;
+        StartTimestamp = DateTime.UtcNow;
+        
+        if (File.Exists("version") && !ConfigService.DebugMode)
+            AppVersion = File.ReadAllText("version");
+        else if (ConfigService.DebugMode)
+        {
+            string repositoryPath = Path.GetFullPath("..");
+            using var repo = new Repository(repositoryPath);
+            var commit = repo.Head.Tip;
+            AppVersion = commit.Sha;
+        }
+        else
+            AppVersion = "unknown";
+
+        Task.Run(FetchChangeLog);
+    }
+
+    private async Task FetchChangeLog()
+    {
+        if (ConfigService.DebugMode)
+        {
+            ChangeLog.Add(new[]
+            {
+                "Disabled",
+                "Fetching changelog from github is disabled in debug mode"
+            });
+            
+            return;
+        }
+
+        try
+        {
+            var client = new GitHubClient(new ProductHeaderValue("Moonlight"));
+            
+            var pullRequests = await client.PullRequest.GetAllForRepository("Moonlight-Panel", "Moonlight", new PullRequestRequest
+            {
+                State = ItemStateFilter.Closed,
+                SortDirection = SortDirection.Ascending,
+                SortProperty = PullRequestSort.Created
+            });
+
+            var groupedPullRequests = new Dictionary<DateTime, List<string>>();
+
+            foreach (var pullRequest in pullRequests)
+            {
+                if (pullRequest.MergedAt != null)
+                {
+                    var date = pullRequest.MergedAt.Value.Date;
+
+                    if (!groupedPullRequests.ContainsKey(date))
+                    {
+                        groupedPullRequests[date] = new List<string>();
+                    }
+
+                    groupedPullRequests[date].Add(pullRequest.Title);
+                }
+            }
+
+            int i = 1;
+            foreach (var group in groupedPullRequests)
+            {
+                var pullRequestsList = new List<string>();
+                var date = group.Key.ToString("dd.MM.yyyy");
+
+                pullRequestsList.Add($"Patch {i}, {date}");
+        
+                foreach (var pullRequest in group.Value)
+                {
+                    pullRequestsList.Add(pullRequest);
+                }
+
+                ChangeLog.Add(pullRequestsList.ToArray());
+                i++;
+            }
+        }
+        catch (Exception e)
+        {
+            Logger.Warn("Error fetching changelog");
+            Logger.Warn(e);
+        }
+    }
+}

Moonlight/App/Services/NodeService.cs

@@ -1,4 +1,5 @@
 using Moonlight.App.ApiClients.Daemon;
+using Moonlight.App.ApiClients.Daemon.Requests;
 using Moonlight.App.ApiClients.Daemon.Resources;
 using Moonlight.App.ApiClients.Wings;
 using Moonlight.App.ApiClients.Wings.Resources;
@@ -24,34 +25,55 @@ public class NodeService
         return await WingsApiHelper.Get<SystemStatus>(node, "api/system");
     }
 
-    public async Task<CpuStats> GetCpuStats(Node node)
+    public async Task<CpuMetrics> GetCpuMetrics(Node node)
     {
-        return await DaemonApiHelper.Get<CpuStats>(node, "stats/cpu");
+        return await DaemonApiHelper.Get<CpuMetrics>(node, "metrics/cpu");
     }
     
-    public async Task<MemoryStats> GetMemoryStats(Node node)
+    public async Task<MemoryMetrics> GetMemoryMetrics(Node node)
     {
-        return await DaemonApiHelper.Get<MemoryStats>(node, "stats/memory");
+        return await DaemonApiHelper.Get<MemoryMetrics>(node, "metrics/memory");
     }
     
-    public async Task<DiskStats> GetDiskStats(Node node)
+    public async Task<DiskMetrics> GetDiskMetrics(Node node)
     {
-        return await DaemonApiHelper.Get<DiskStats>(node, "stats/disk");
+        return await DaemonApiHelper.Get<DiskMetrics>(node, "metrics/disk");
     }
     
-    public async Task<ContainerStats> GetContainerStats(Node node)
+    public async Task<SystemMetrics> GetSystemMetrics(Node node)
     {
-        return await DaemonApiHelper.Get<ContainerStats>(node, "stats/container");
+        return await DaemonApiHelper.Get<SystemMetrics>(node, "metrics/system");
+    }
+    
+    public async Task<DockerMetrics> GetDockerMetrics(Node node)
+    {
+        return await DaemonApiHelper.Get<DockerMetrics>(node, "metrics/docker");
+    }
+
+    public async Task Mount(Node node, string server, string serverPath, string path)
+    {
+        await DaemonApiHelper.Post(node, "mount", new Mount()
+        {
+            Server = server,
+            ServerPath = serverPath,
+            Path = path
+        });
+    }
+
+    public async Task Unmount(Node node, string path)
+    {
+        await DaemonApiHelper.Delete(node, "mount", new Unmount()
+        {
+            Path = path
+        });
     }
 
     public async Task<bool> IsHostUp(Node node)
     {
         try
         {
-            //TODO: Implement status caching
-            var data = await GetStatus(node);
+            await GetStatus(node);
 
-            if (data != null)
             return true;
         }
         catch (Exception)

Moonlight/App/Services/Notifications/NotificationClientService.cs

@@ -1,43 +0,0 @@
-using System.Net.WebSockets;
-using System.Text;
-using Moonlight.App.Database.Entities;
-using Moonlight.App.Database.Entities.Notification;
-using Moonlight.App.Http.Controllers.Api.Moonlight.Notifications;
-using Moonlight.App.Repositories;
-using Moonlight.App.Services.Sessions;
-
-namespace Moonlight.App.Services.Notifications;
-
-public class NotificationClientService
-{
-    private readonly NotificationRepository NotificationRepository;
-    private readonly NotificationServerService NotificationServerService;
-    internal ListenController listenController;
-    
-    public NotificationClientService(NotificationRepository notificationRepository, NotificationServerService notificationServerService)
-    {
-        NotificationRepository = notificationRepository;
-        NotificationServerService = notificationServerService;
-    }
-
-    public User User => NotificationClient.User;
-    
-    public NotificationClient NotificationClient { get; set; }
-
-    public async Task SendAction(string action)
-    {
-        await listenController.ws.SendAsync(Encoding.UTF8.GetBytes(action), WebSocketMessageType.Text,
-            WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
-    }
-
-    public void WebsocketReady(NotificationClient client)
-    {
-        NotificationClient = client;
-        NotificationServerService.AddClient(this);
-    }
-
-    public void WebsocketClosed()
-    {
-        NotificationServerService.RemoveClient(this);
-    }
-}

Moonlight/App/Services/Notifications/NotificationServerService.cs

@@ -1,51 +1,75 @@
-using Microsoft.EntityFrameworkCore;
+using System.Net.WebSockets;
+using System.Text;
+using Microsoft.EntityFrameworkCore;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Database.Entities.Notification;
+using Moonlight.App.Events;
+using Moonlight.App.Models.Misc;
 using Moonlight.App.Repositories;
 
 namespace Moonlight.App.Services.Notifications;
 
 public class NotificationServerService
 {
-    private UserRepository UserRepository;
-    private NotificationRepository NotificationRepository;
+    private readonly List<ActiveNotificationClient> ActiveClients = new();
 
     private readonly IServiceScopeFactory ServiceScopeFactory;
-    private IServiceScope ServiceScope;
+    private readonly EventSystem Event;
 
-    public NotificationServerService(IServiceScopeFactory serviceScopeFactory)
+    public NotificationServerService(IServiceScopeFactory serviceScopeFactory, EventSystem eventSystem)
     {
         ServiceScopeFactory = serviceScopeFactory;
-        Task.Run(Run);
+        Event = eventSystem;
     }
 
-    private Task Run()
+    public Task<ActiveNotificationClient[]> GetActiveClients()
     {
-        ServiceScope = ServiceScopeFactory.CreateScope();
-
-        UserRepository = ServiceScope
-            .ServiceProvider
-            .GetRequiredService<UserRepository>();
-
-        NotificationRepository = ServiceScope
-            .ServiceProvider
-            .GetRequiredService<NotificationRepository>();
-        
-        return Task.CompletedTask;
+        lock (ActiveClients)
+        {
+            return Task.FromResult(ActiveClients.ToArray());
+        }
     }
 
-    private List<NotificationClientService> connectedClients = new();
-
-    public List<NotificationClientService> GetConnectedClients(User user)
+    public Task<ActiveNotificationClient[]> GetUserClients(User user)
     {
-        return connectedClients.Where(x => x.User == user).ToList();
+        lock (ActiveClients)
+        {
+            return Task.FromResult(
+                ActiveClients
+                    .Where(x => x.Client.User.Id == user.Id)
+                    .ToArray()
+            );
+        }
     }
 
     public async Task SendAction(User user, string action)
     {
-        var clients = NotificationRepository.GetClients().Include(x => x.User).Where(x => x.User == user).ToList();
+        using var scope = ServiceScopeFactory.CreateScope();
+        var notificationClientRepository =
+            scope.ServiceProvider.GetRequiredService<Repository<NotificationClient>>();
+        
+        var clients = notificationClientRepository
+            .Get()
+            .Include(x => x.User)
+            .Where(x => x.User == user)
+            .ToList();
 
         foreach (var client in clients)
+        {
+            ActiveNotificationClient[] connectedUserClients;
+
+            lock (ActiveClients)
+            {
+                connectedUserClients = ActiveClients
+                    .Where(x => x.Client.Id == user.Id)
+                    .ToArray();
+            }
+            
+            if (connectedUserClients.Length > 0)
+            {
+                await connectedUserClients[0].SendAction(action);
+            }
+            else
             {
                 var notificationAction = new NotificationAction()
                 {
@@ -53,27 +77,37 @@ public class NotificationServerService
                     NotificationClient = client
                 };
                 
-            var connected = connectedClients.Where(x => x.NotificationClient.Id == client.Id).ToList();
+                var notificationActionsRepository =
+                    scope.ServiceProvider.GetRequiredService<Repository<NotificationAction>>();
 
-            if (connected.Count > 0)
-            {
-                var clientService = connected[0];
-                await clientService.SendAction(action);
-            }
-            else
-            {
-                NotificationRepository.AddAction(notificationAction);
+                notificationActionsRepository.Add(notificationAction);
             }
         }
     }
 
-    public void AddClient(NotificationClientService notificationClientService)
+    public async Task RegisterClient(WebSocket webSocket, NotificationClient notificationClient)
     {
-        connectedClients.Add(notificationClientService);
+        var newClient = new ActiveNotificationClient()
+        {
+            WebSocket = webSocket,
+            Client = notificationClient
+        };
+        
+        lock (ActiveClients)
+        {
+            ActiveClients.Add(newClient);
         }
 
-    public void RemoveClient(NotificationClientService notificationClientService)
+        await Event.Emit("notifications.addClient", notificationClient);
+    }
+
+    public async Task UnRegisterClient(NotificationClient client)
     {
-        connectedClients.Remove(notificationClientService);
+        lock (ActiveClients)
+        {
+            ActiveClients.RemoveAll(x => x.Client == client);
+        }
+        
+        await Event.Emit("notifications.removeClient", client);
     }
 }

Moonlight/App/Services/OAuth2Service.cs

@@ -80,6 +80,26 @@ public class OAuth2Service
         return await provider.HandleCode(code);
     }
 
+    public Task<bool> CanBeLinked(string id)
+    {
+        if (Providers.All(x => x.Key != id))
+            throw new DisplayException("Invalid oauth2 id");
+
+        var provider = Providers[id];
+
+        return Task.FromResult(provider.CanBeLinked);
+    }
+
+    public async Task LinkToUser(string id, User user, string code)
+    {
+        if (Providers.All(x => x.Key != id))
+            throw new DisplayException("Invalid oauth2 id");
+
+        var provider = Providers[id];
+
+        await provider.LinkToUser(user, code);
+    }
+
     private string GetAppUrl()
     {
         if (EnableOverrideUrl)

Moonlight/App/Services/ServerService.cs

@@ -1,4 +1,5 @@
-using Microsoft.EntityFrameworkCore;
+using Logging.Net;
+using Microsoft.EntityFrameworkCore;
 using Moonlight.App.ApiClients.Wings;
 using Moonlight.App.ApiClients.Wings.Requests;
 using Moonlight.App.ApiClients.Wings.Resources;
@@ -8,6 +9,7 @@ using Moonlight.App.Events;
 using Moonlight.App.Exceptions;
 using Moonlight.App.Helpers;
 using Moonlight.App.Helpers.Files;
+using Moonlight.App.Helpers.Wings;
 using Moonlight.App.Models.Misc;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;
@@ -18,6 +20,7 @@ namespace Moonlight.App.Services;
 
 public class ServerService
 {
+    private readonly Repository<ServerVariable> ServerVariablesRepository;
     private readonly ServerRepository ServerRepository;
     private readonly UserRepository UserRepository;
     private readonly ImageRepository ImageRepository;
@@ -49,7 +52,8 @@ public class ServerService
         NodeService nodeService,
         NodeAllocationRepository nodeAllocationRepository,
         DateTimeService dateTimeService,
-        EventSystem eventSystem)
+        EventSystem eventSystem,
+        Repository<ServerVariable> serverVariablesRepository)
     {
         ServerRepository = serverRepository;
         WingsApiHelper = wingsApiHelper;
@@ -66,6 +70,7 @@ public class ServerService
         NodeAllocationRepository = nodeAllocationRepository;
         DateTimeService = dateTimeService;
         Event = eventSystem;
+        ServerVariablesRepository = serverVariablesRepository;
     }
 
     private Server EnsureNodeData(Server s)
@@ -365,6 +370,9 @@ public class ServerService
 
         await WingsApiHelper.Post(server.Node, $"api/servers/{server.Uuid}/reinstall", null);
 
+        server.Installing = true;
+        ServerRepository.Update(server);
+        
         await AuditLogService.Log(AuditLogType.ReinstallServer, x => { x.Add<Server>(server.Uuid); });
     }
 
@@ -400,17 +408,15 @@ public class ServerService
 
     public async Task Delete(Server s)
     {
-        throw new DisplayException("Deleting a server is currently a bit buggy. So its disabled for your safety");
+        throw new DisplayException("Deleting servers is currently disabled");
         
-        var server = EnsureNodeData(s);
-
-        var backups = await GetBackups(server);
+        var backups = await GetBackups(s);
 
         foreach (var backup in backups)
         {
             try
             {
-                await DeleteBackup(server, backup);
+                await DeleteBackup(s, backup);
             }
             catch (Exception)
             {
@@ -418,9 +424,18 @@ public class ServerService
             }
         }
 
+        var server = ServerRepository
+            .Get()
+            .Include(x => x.Variables)
+            .Include(x => x.Node)
+            .First(x => x.Id == s.Id);
+
         await WingsApiHelper.Delete(server.Node, $"api/servers/{server.Uuid}", null);
 
-        //TODO: Fix empty data models
+        foreach (var variable in server.Variables.ToArray())
+        {
+            ServerVariablesRepository.Delete(variable);
+        }
 
         server.Allocations = new();
         server.MainAllocation = null;
@@ -428,7 +443,6 @@ public class ServerService
         server.Backups = new();
 
         ServerRepository.Update(server);
-
         ServerRepository.Delete(server);
     }
 
@@ -438,4 +452,65 @@ public class ServerService
 
         return await NodeService.IsHostUp(server.Node);
     }
+
+    public async Task ArchiveServer(Server server)
+    {
+        if (server.IsArchived)
+            throw new DisplayException("Unable to archive an already archived server");
+        
+        // Archive server
+        
+        var backup = await CreateBackup(server);
+        server.IsArchived = true;
+        server.Archive = backup;
+        
+        ServerRepository.Update(server);
+
+        await Event.WaitForEvent<ServerBackup>("wings.backups.create", this, x => backup.Id == x.Id);
+
+        // Reset server
+        
+        var access = await CreateFileAccess(server, null!);
+        var files = await access.Ls();
+        foreach (var file in files)
+        {
+            try
+            {
+                await access.Delete(file);
+            }
+            catch (Exception)
+            {
+                // ignored
+            }
+        }
+        
+        await Event.Emit($"server.{server.Uuid}.archiveStatusChanged", server);
+    }
+
+    public async Task UnArchiveServer(Server s)
+    {
+        if (!s.IsArchived)
+            throw new DisplayException("Unable to unarchive a server which is not archived");
+
+        var server = ServerRepository
+            .Get()
+            .Include(x => x.Archive)
+            .First(x => x.Id == s.Id);
+
+        if (server.Archive == null)
+            throw new DisplayException("Archive from server not found");
+
+        if (!server.Archive.Created)
+            throw new DisplayException("Creating the server archive is in progress");
+
+        await RestoreBackup(server, server.Archive);
+
+        await Event.WaitForEvent<ServerBackup>("wings.backups.restore", this, 
+            x => x.Id == server.Archive.Id);
+
+        server.IsArchived = false;
+        ServerRepository.Update(server);
+
+        await Event.Emit($"server.{server.Uuid}.archiveStatusChanged", server);
+    }
 }

Moonlight/App/Services/Sessions/BundleService.cs

@@ -1,129 +0,0 @@
-using Logging.Net;
-
-namespace Moonlight.App.Services.Sessions;
-
-public class BundleService
-{
-    public BundleService(ConfigService configService)
-    {
-        var url = configService
-            .GetSection("Moonlight")
-            .GetValue<string>("AppUrl");
-        
-        #region JS
-
-        JsFiles = new();
-
-        JsFiles.AddRange(new[]
-        {
-            url + "/_framework/blazor.server.js",
-            url + "/assets/plugins/global/plugins.bundle.js",
-            url + "/_content/XtermBlazor/XtermBlazor.min.js",
-            url + "/_content/BlazorTable/BlazorTable.min.js",
-            url + "/_content/CurrieTechnologies.Razor.SweetAlert2/sweetAlert2.min.js",
-            url + "/_content/Blazor.ContextMenu/blazorContextMenu.min.js",
-            "https://www.google.com/recaptcha/api.js",
-            "https://cdn.jsdelivr.net/npm/xterm-addon-fit@0.5.0/lib/xterm-addon-fit.min.js",
-            "https://cdn.jsdelivr.net/npm/xterm-addon-search@0.8.2/lib/xterm-addon-search.min.js",
-            "https://cdn.jsdelivr.net/npm/xterm-addon-web-links@0.5.0/lib/xterm-addon-web-links.min.js",
-            url + "/_content/BlazorMonaco/lib/monaco-editor/min/vs/loader.js",
-            "require.config({ paths: { 'vs': '/_content/BlazorMonaco/lib/monaco-editor/min/vs' } });",
-            url + "/_content/BlazorMonaco/lib/monaco-editor/min/vs/editor/editor.main.js",
-            url + "/_content/BlazorMonaco/jsInterop.js",
-            url + "/assets/js/scripts.bundle.js",
-            url + "/assets/js/moonlight.js",
-            "moonlight.loading.registerXterm();",
-            url + "/_content/Blazor-ApexCharts/js/apex-charts.min.js",
-            url + "/_content/Blazor-ApexCharts/js/blazor-apex-charts.js"
-        });
-
-        #endregion
-
-        #region CSS
-
-        CssFiles = new();
-
-        CssFiles.AddRange(new[]
-        {
-            "https://fonts.googleapis.com/css?family=Poppins:300,400,500,600,700",
-            url + "/assets/css/style.bundle.css",
-            url + "/assets/css/flashbang.css",
-            url + "/assets/css/snow.css",
-            url + "/assets/css/utils.css",
-            url + "/assets/css/blazor.css",
-            url + "/_content/XtermBlazor/XtermBlazor.css",
-            url + "/_content/BlazorMonaco/lib/monaco-editor/min/vs/editor/editor.main.css",
-            url + "/_content/Blazor.ContextMenu/blazorContextMenu.min.css",
-            url + "/assets/plugins/global/plugins.bundle.css"
-        });
-        
-        #endregion
-
-        CacheId = Guid.NewGuid().ToString();
-
-        Task.Run(Bundle);
-    }
-
-    // Javascript
-    public string BundledJs { get; private set; }
-    public readonly List<string> JsFiles;
-
-    // CSS
-    public string BundledCss { get; private set; }
-    public readonly List<string> CssFiles;
-
-    // States
-    public string CacheId { get; private set; }
-    public bool BundledFinished { get; set; } = false;
-    private bool IsBundling { get; set; } = false;
-
-    private async Task Bundle()
-    {
-        if (!IsBundling)
-            IsBundling = true;
-
-        Logger.Info("Bundling js and css files");
-
-        BundledJs = "";
-        BundledCss = "";
-
-        BundledJs = await BundleFiles(
-            JsFiles
-        );
-
-        BundledCss = await BundleFiles(
-            CssFiles
-        );
-
-        Logger.Info("Successfully bundled");
-        BundledFinished = true;
-    }
-
-    private async Task<string> BundleFiles(IEnumerable<string> items)
-    {
-        var bundled = "";
-
-        using HttpClient client = new HttpClient();
-        foreach (string item in items)
-        {
-            // Item is a url, fetch it
-            if (item.StartsWith("http"))
-            {
-                try
-                {
-                    var jsCode = await client.GetStringAsync(item);
-                    bundled += jsCode + "\n";
-                }
-                catch (Exception e)
-                {
-                    Logger.Warn($"Error fetching '{item}' while bundling");
-                    Logger.Warn(e);
-                }
-            }
-            else // If not, it is probably a manual addition, so add it
-                bundled += item + "\n";
-        }
-
-        return bundled;
-    }
-}

Moonlight/App/Services/Sessions/DynamicBackgroundService.cs

@@ -0,0 +1,39 @@
+using Logging.Net;
+using Moonlight.App.Services.Files;
+
+namespace Moonlight.App.Services.Sessions;
+
+public class DynamicBackgroundService
+{
+    public EventHandler OnBackgroundImageChanged { get; set; }
+    public string BackgroundImageUrl { get; private set; }
+    private string DefaultBackgroundImageUrl;
+
+    public DynamicBackgroundService(ResourceService resourceService)
+    {
+        DefaultBackgroundImageUrl = resourceService.BackgroundImage("main.jpg");
+        BackgroundImageUrl = DefaultBackgroundImageUrl;
+    }
+
+    public Task Change(string url)
+    {
+        if(BackgroundImageUrl == url) // Prevent unnecessary updates
+            return Task.CompletedTask;
+        
+        BackgroundImageUrl = url;
+        OnBackgroundImageChanged?.Invoke(this, null!);
+
+        return Task.CompletedTask;
+    }
+
+    public Task Reset()
+    {
+        if(BackgroundImageUrl == DefaultBackgroundImageUrl) // Prevent unnecessary updates
+            return Task.CompletedTask;
+        
+        BackgroundImageUrl = DefaultBackgroundImageUrl;
+        OnBackgroundImageChanged?.Invoke(this, null!);
+
+        return Task.CompletedTask;
+    }
+}

Moonlight/App/Services/Sessions/IdentityService.cs

@@ -159,8 +159,17 @@ public class IdentityService
 
         try
         {
+            var userAgent = HttpContextAccessor.HttpContext.Request.Headers.UserAgent.ToString();
+
+            if (userAgent.Contains("Moonlight.App"))
+            {
+                var version = userAgent.Remove(0, "Moonlight.App/".Length).Split(' ').FirstOrDefault();
+
+                return "Moonlight App " + version;
+            }
+            
             var uaParser = Parser.GetDefault();
-            var info = uaParser.Parse(HttpContextAccessor.HttpContext.Request.Headers.UserAgent);
+            var info = uaParser.Parse(userAgent);
 
             return $"{info.OS} - {info.Device}";
         }

Moonlight/App/Services/Sessions/SessionService.cs

@@ -9,6 +9,7 @@ namespace Moonlight.App.Services.Sessions;
 public class SessionService
 {
     private readonly SessionRepository SessionRepository;
+    private Repository<User> UserRepository;
     private readonly IdentityService IdentityService;
     private readonly NavigationManager NavigationManager;
     private readonly AlertService AlertService;
@@ -21,13 +22,15 @@ public class SessionService
         IdentityService identityService, 
         NavigationManager navigationManager,
         AlertService alertService,
-        DateTimeService dateTimeService)
+        DateTimeService dateTimeService,
+        Repository<User> userRepository)
     {
         SessionRepository = sessionRepository;
         IdentityService = identityService;
         NavigationManager = navigationManager;
         AlertService = alertService;
         DateTimeService = dateTimeService;
+        UserRepository = userRepository;
     }
 
     public async Task Register()
@@ -46,6 +49,12 @@ public class SessionService
         };
         
         SessionRepository.Add(OwnSession);
+
+        if (user != null) // Track last session init of user as last visited timestamp
+        {
+            user.LastVisitedAt = DateTimeService.GetCurrent();
+            UserRepository.Update(user);
+        }
     }
 
     public void Refresh()

Moonlight/App/Services/SmartDeployService.cs

@@ -9,21 +9,36 @@ public class SmartDeployService
     private readonly Repository<CloudPanel> CloudPanelRepository;
     private readonly WebSpaceService WebSpaceService;
     private readonly NodeService NodeService;
+    private readonly ConfigService ConfigService;
 
     public SmartDeployService(
         NodeRepository nodeRepository,
         NodeService nodeService,
         WebSpaceService webSpaceService,
-        Repository<CloudPanel> cloudPanelRepository)
+        Repository<CloudPanel> cloudPanelRepository,
+        ConfigService configService)
     {
         NodeRepository = nodeRepository;
         NodeService = nodeService;
         WebSpaceService = webSpaceService;
         CloudPanelRepository = cloudPanelRepository;
+        ConfigService = configService;
     }
 
     public async Task<Node?> GetNode()
     {
+        var config = ConfigService
+            .GetSection("Moonlight")
+            .GetSection("SmartDeploy")
+            .GetSection("Server");
+
+        if (config.GetValue<bool>("EnableOverride"))
+        {
+            var nodeId = config.GetValue<int>("OverrideNode");
+
+            return NodeRepository.Get().FirstOrDefault(x => x.Id == nodeId);
+        }
+        
         var data = new Dictionary<Node, double>();
 
         foreach (var node in NodeRepository.Get().ToArray())
@@ -59,17 +74,17 @@ public class SmartDeployService
 
         try
         {
-            var cpuStats = await NodeService.GetCpuStats(node);
-            var memoryStats = await NodeService.GetMemoryStats(node);
-            var diskStats = await NodeService.GetDiskStats(node);
+            var cpuMetrics = await NodeService.GetCpuMetrics(node);
+            var memoryMetrics = await NodeService.GetMemoryMetrics(node);
+            var diskMetrics = await NodeService.GetDiskMetrics(node);
             
             var cpuWeight = 0.5; // Weight of CPU usage in the final score
             var memoryWeight = 0.3; // Weight of memory usage in the final score
             var diskSpaceWeight = 0.2; // Weight of free disk space in the final score
 
-            var cpuScore = (1 - cpuStats.Usage) * cpuWeight; // CPU score is based on the inverse of CPU usage
-            var memoryScore = (1 - (memoryStats.Used / 1024)) * memoryWeight; // Memory score is based on the percentage of free memory
-            var diskSpaceScore = (double) diskStats.FreeBytes / 1000000000 * diskSpaceWeight; // Disk space score is based on the amount of free disk space in GB
+            var cpuScore = (1 - cpuMetrics.CpuUsage) * cpuWeight; // CPU score is based on the inverse of CPU usage
+            var memoryScore = (1 - (memoryMetrics.Used / 1024)) * memoryWeight; // Memory score is based on the percentage of free memory
+            var diskSpaceScore = (double) (diskMetrics.Total - diskMetrics.Used) / 1000000000 * diskSpaceWeight; // Disk space score is based on the amount of free disk space in GB
 
             var finalScore = cpuScore + memoryScore + diskSpaceScore;
 

Moonlight/App/Services/Statistics/StatisticsViewService.cs

@@ -7,20 +7,33 @@ namespace Moonlight.App.Services.Statistics;
 public class StatisticsViewService
 {
     private readonly StatisticsRepository StatisticsRepository;
+    private readonly Repository<User> UserRepository;
     private readonly DateTimeService DateTimeService;
     
-    public StatisticsViewService(StatisticsRepository statisticsRepository, DateTimeService dateTimeService)
+    public StatisticsViewService(StatisticsRepository statisticsRepository, DateTimeService dateTimeService, Repository<User> userRepository)
     {
         StatisticsRepository = statisticsRepository;
         DateTimeService = dateTimeService;
+        UserRepository = userRepository;
     }
 
     public StatisticsData[] GetData(string chart, StatisticsTimeSpan timeSpan)
     {
         var startDate = DateTimeService.GetCurrent() - TimeSpan.FromHours((int)timeSpan);
 
-        var objs = StatisticsRepository.Get().Where(x => x.Date > startDate && x.Chart == chart);
+        var objs = StatisticsRepository
+            .Get()
+            .Where(x => x.Date > startDate && x.Chart == chart);
 
         return objs.ToArray();
     }
+
+    public int GetActiveUsers(StatisticsTimeSpan timeSpan)
+    {
+        var startDate = DateTimeService.GetCurrent() - TimeSpan.FromHours((int)timeSpan);
+
+        return UserRepository
+            .Get()
+            .Count(x => x.LastVisitedAt > startDate);
+    }
 }

Moonlight/App/Services/WebSpaceService.cs

@@ -1,4 +1,7 @@
-using Microsoft.EntityFrameworkCore;
+using System.Net;
+using DnsClient;
+using Logging.Net;
+using Microsoft.EntityFrameworkCore;
 using Moonlight.App.ApiClients.CloudPanel;
 using Moonlight.App.ApiClients.CloudPanel.Requests;
 using Moonlight.App.Database.Entities;
@@ -18,7 +21,8 @@ public class WebSpaceService
 
     private readonly CloudPanelApiHelper CloudPanelApiHelper;
 
-    public WebSpaceService(Repository<CloudPanel> cloudPanelRepository, Repository<WebSpace> webSpaceRepository, CloudPanelApiHelper cloudPanelApiHelper, Repository<MySqlDatabase> databaseRepository)
+    public WebSpaceService(Repository<CloudPanel> cloudPanelRepository, Repository<WebSpace> webSpaceRepository,
+        CloudPanelApiHelper cloudPanelApiHelper, Repository<MySqlDatabase> databaseRepository)
     {
         CloudPanelRepository = cloudPanelRepository;
         WebSpaceRepository = webSpaceRepository;
@@ -72,11 +76,21 @@ public class WebSpaceService
 
     public async Task Delete(WebSpace w)
     {
-        var website = EnsureData(w);
+        var webSpace = WebSpaceRepository
+            .Get()
+            .Include(x => x.Databases)
+            .Include(x => x.CloudPanel)
+            .Include(x => x.Owner)
+            .First(x => x.Id == w.Id);
 
-        await CloudPanelApiHelper.Delete(website.CloudPanel, $"site/{website.Domain}", null);
+        foreach (var database in webSpace.Databases.ToArray())
+        {
+            await DeleteDatabase(webSpace, database);
+        }
 
-        WebSpaceRepository.Delete(website);
+        await CloudPanelApiHelper.Delete(webSpace.CloudPanel, $"site/{webSpace.Domain}", null);
+
+        WebSpaceRepository.Delete(webSpace);
     }
 
     public async Task<bool> IsHostUp(CloudPanel cloudPanel)
@@ -111,6 +125,52 @@ public class WebSpaceService
     {
         var webspace = EnsureData(w);
 
+        var dns = new LookupClient(new LookupClientOptions()
+        {
+            CacheFailedResults = false,
+            UseCache = false
+        });
+
+        var ipOfWebspaceQuery = await dns.QueryAsync(
+            webspace.Domain,
+            QueryType.A
+        );
+
+        var ipOfWebspaceWwwQuery = await dns.QueryAsync(
+            "www." + webspace.Domain,
+            QueryType.CNAME
+        );
+
+        var ipOfWebspace = ipOfWebspaceQuery.Answers.ARecords().FirstOrDefault();
+        var ipOfWebspaceWww = ipOfWebspaceWwwQuery.Answers.CnameRecords().FirstOrDefault();
+
+        if (ipOfWebspace == null)
+            throw new DisplayException($"Unable to find any a records for {webspace.Domain}", true);
+
+        if (ipOfWebspaceWww == null)
+            throw new DisplayException($"Unable to find any cname records for www.{webspace.Domain}", true);
+
+        var ipOfHostQuery = await dns.QueryAsync(
+            webspace.CloudPanel.Host,
+            QueryType.A
+        );
+
+        var ipOfHost = ipOfHostQuery.Answers.ARecords().FirstOrDefault();
+
+
+        if (ipOfHost == null)
+            throw new DisplayException("Unable to find a record of host system");
+
+        if (ipOfHost.Address.ToString() != ipOfWebspace.Address.ToString())
+            throw new DisplayException("The dns records of your webspace do not point to the host system");
+
+        Logger.Debug($"{ipOfWebspaceWww.CanonicalName.Value}");
+
+        if (ipOfWebspaceWww.CanonicalName.Value != webspace.CloudPanel.Host + ".")
+            throw new DisplayException(
+                $"The dns record www.{webspace.Domain} does not point to {webspace.CloudPanel.Host}", true);
+
+
         await CloudPanelApiHelper.Post(webspace.CloudPanel, "letsencrypt/install/certificate", new InstallLetsEncrypt()
         {
             DomainName = webspace.Domain
@@ -170,7 +230,8 @@ public class WebSpaceService
         var webspace = EnsureData(w);
 
         return Task.FromResult<FileAccess>(
-            new SftpFileAccess(webspace.CloudPanel.Host, webspace.UserName, webspace.Password, 22, true, $"/htdocs/{webspace.Domain}")
+            new SftpFileAccess(webspace.CloudPanel.Host, webspace.UserName, webspace.Password, 22, true,
+                $"/htdocs/{webspace.Domain}")
         );
     }
 

Moonlight/Moonlight.csproj

@@ -9,6 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="AspNetCore.HealthChecks.UI.Client" Version="6.0.5" />
     <PackageReference Include="Blazor-ApexCharts" Version="0.9.16-beta" />
     <PackageReference Include="BCrypt.Net-Next" Version="4.0.3" />
     <PackageReference Include="Ben.Demystifier" Version="0.4.1" />
@@ -20,9 +21,11 @@
     <PackageReference Include="CurrieTechnologies.Razor.SweetAlert2" Version="5.4.0" />
     <PackageReference Include="Discord.Net" Version="3.10.0" />
     <PackageReference Include="Discord.Net.Webhook" Version="3.10.0" />
+    <PackageReference Include="DnsClient" Version="1.7.0" />
     <PackageReference Include="FluentFTP" Version="46.0.2" />
     <PackageReference Include="GravatarSharp.Core" Version="1.0.1.2" />
     <PackageReference Include="JWT" Version="10.0.2" />
+    <PackageReference Include="LibGit2Sharp" Version="0.27.2" />
     <PackageReference Include="Logging.Net" Version="1.1.3" />
     <PackageReference Include="MailKit" Version="4.0.0" />
     <PackageReference Include="Mappy.Net" Version="1.0.2" />
@@ -39,14 +42,14 @@
     <PackageReference Include="MineStat" Version="3.1.1" />
     <PackageReference Include="MySqlBackup.NET" Version="2.3.8" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3-beta1" />
+    <PackageReference Include="Octokit" Version="6.0.0" />
     <PackageReference Include="Otp.NET" Version="1.3.0" />
     <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="7.0.0" />
-    <PackageReference Include="PteroConsole.NET" Version="1.0.4" />
     <PackageReference Include="QRCoder" Version="1.4.3" />
     <PackageReference Include="RestSharp" Version="109.0.0-preview.1" />
     <PackageReference Include="SSH.NET" Version="2020.0.2" />
     <PackageReference Include="UAParser" Version="3.1.47" />
-    <PackageReference Include="XtermBlazor" Version="1.6.1" />
+    <PackageReference Include="XtermBlazor" Version="1.8.1" />
   </ItemGroup>
 
   <ItemGroup>
@@ -72,9 +75,27 @@
 
   <ItemGroup>
     <Folder Include="App\ApiClients\CloudPanel\Resources\" />
-    <Folder Include="App\ApiClients\Daemon\Requests\" />
     <Folder Include="App\Http\Middleware" />
     <Folder Include="storage\backups\" />
+    <Folder Include="storage\resources\public\background\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <AdditionalFiles Include="Shared\Views\Server\Settings\DotnetFileSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\DotnetVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\FabricVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\ForgeVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\JavaFileSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\JavaRuntimeVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\JavascriptFileSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\JavascriptVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\Join2StartSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\PaperVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\PythonFileSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\PythonVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\ServerDeleteSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\ServerRenameSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\ServerResetSetting.razor" />
   </ItemGroup>
 
 </Project>

Moonlight/Pages/_Layout.cshtml

@@ -7,7 +7,6 @@
 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
 
 @inject ConfigService ConfigService
-@inject BundleService BundleService
 @inject LoadingMessageRepository LoadingMessageRepository
 
 @{
@@ -38,29 +37,20 @@
 
     <link rel="shortcut icon" href="@(moonlightConfig.GetValue<string>("AppUrl"))/api/moonlight/resources/images/logo.svg"/>
 
-    @*This import is not in the bundle because the files it references are linked relative to the current lath*@
-    <link rel="stylesheet" type="text/css" href="/assets/css/boxicons.min.css"/>
+    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Poppins:300,400,500,600,700"/>
 
-    @if (BundleService.BundledFinished)
-    {
-        <link rel="stylesheet" type="text/css" href="/api/moonlight/resources/bundle/css?idontwannabecached=@(BundleService.CacheId)"/>
-    }
-    else
-    {
-        foreach (var cssFile in BundleService.CssFiles)
-        {
-            if (cssFile.StartsWith("http"))
-            {
-                <link rel="stylesheet" type="text/css" href="@(cssFile)">
-            }
-            else
-            {
-                <style>
-                    @cssFile
-                </style>
-            }
-        }
-    }
+    <link rel="stylesheet" type="text/css" href="/assets/css/style.bundle.css"/>
+    <link rel="stylesheet" type="text/css" href="/assets/css/flashbang.css"/>
+    <link rel="stylesheet" type="text/css" href="/assets/css/snow.css"/>
+    <link rel="stylesheet" type="text/css" href="/assets/css/utils.css"/>
+    <link rel="stylesheet" type="text/css" href="/assets/css/boxicons.min.css"/>
+    <link rel="stylesheet" type="text/css" href="/assets/css/blazor.css"/>
+
+    <link rel="stylesheet" type="text/css" href="/_content/XtermBlazor/XtermBlazor.css"/>
+    <link rel="stylesheet" type="text/css" href="/_content/BlazorMonaco/lib/monaco-editor/min/vs/editor/editor.main.css"/>
+    <link rel="stylesheet" type="text/css" href="/_content/Blazor.ContextMenu/blazorContextMenu.min.css"/>
+
+    <link href="/assets/plugins/global/plugins.bundle.css" rel="stylesheet" type="text/css"/>
 
     <meta name="viewport" content="width=device-width, initial-scale=1"/>
     <base href="~/"/>
@@ -106,24 +96,31 @@
     </div>
 </div>
 
-@if (BundleService.BundledFinished)
-{
-    <script src="/api/moonlight/resources/bundle/js?idontwannabecached=@(BundleService.CacheId)">
-    </script>
-}
-else
-{
-    foreach (var jsFile in BundleService.JsFiles)
-    {
-        if (jsFile.StartsWith("http"))
-        {
-            <script src="@(jsFile)"></script>
-        }
-        else
-        {
-            @Html.Raw("<script>" + jsFile +"</script>")
-        }
-    }
-}
+<script src="/_framework/blazor.server.js"></script>
+<script src="/assets/plugins/global/plugins.bundle.js"></script>
+<script src="/_content/XtermBlazor/XtermBlazor.min.js"></script>
+<script src="/_content/BlazorTable/BlazorTable.min.js"></script>
+<script src="/_content/CurrieTechnologies.Razor.SweetAlert2/sweetAlert2.min.js"></script>
+<script src="/_content/Blazor.ContextMenu/blazorContextMenu.min.js"></script>
+
+<script src="https://www.google.com/recaptcha/api.js"></script>
+
+<script src="https://cdn.jsdelivr.net/npm/xterm-addon-fit@0.7.0/lib/xterm-addon-fit.min.js"></script>
+
+<script src="/_content/BlazorMonaco/lib/monaco-editor/min/vs/loader.js"></script>
+<script>require.config({ paths: { 'vs': '/_content/BlazorMonaco/lib/monaco-editor/min/vs' } });</script>
+<script src="/_content/BlazorMonaco/lib/monaco-editor/min/vs/editor/editor.main.js"></script>
+<script src="/_content/BlazorMonaco/jsInterop.js"></script>
+
+<script src="/assets/js/scripts.bundle.js"></script>
+<script src="/assets/js/moonlight.js"></script>
+
+<script>
+moonlight.loading.registerXterm();
+</script>
+
+<script src="_content/Blazor-ApexCharts/js/apex-charts.min.js"></script>
+<script src="_content/Blazor-ApexCharts/js/blazor-apex-charts.js"></script>
+
 </body>
 </html>

Moonlight/Program.cs

@@ -1,20 +1,25 @@
 using BlazorDownloadFile;
 using BlazorTable;
 using CurrieTechnologies.Razor.SweetAlert2;
+using HealthChecks.UI.Client;
 using Logging.Net;
 using Moonlight.App.ApiClients.CloudPanel;
 using Moonlight.App.ApiClients.Daemon;
+using Moonlight.App.ApiClients.Modrinth;
 using Moonlight.App.ApiClients.Paper;
 using Moonlight.App.ApiClients.Wings;
 using Moonlight.App.Database;
+using Moonlight.App.Diagnostics.HealthChecks;
 using Moonlight.App.Events;
 using Moonlight.App.Helpers;
+using Moonlight.App.Helpers.Wings;
 using Moonlight.App.LogMigrator;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Domains;
 using Moonlight.App.Repositories.LogEntries;
 using Moonlight.App.Repositories.Servers;
 using Moonlight.App.Services;
+using Moonlight.App.Services.Addon;
 using Moonlight.App.Services.Background;
 using Moonlight.App.Services.DiscordBot;
 using Moonlight.App.Services.Files;
@@ -31,9 +36,6 @@ namespace Moonlight
 {
     public class Program
     {
-        // App version. Change for release
-        public static readonly string AppVersion = $"InDev {Formatter.FormatDateOnly(DateTime.Now.Date)}";
-
         public static async Task Main(string[] args)
         {
             Logger.UsedLogger = new CacheLogger();
@@ -65,6 +67,10 @@ namespace Moonlight
                     options.HandshakeTimeout = TimeSpan.FromSeconds(10);
                 });
             builder.Services.AddHttpContextAccessor();
+            builder.Services.AddHealthChecks()
+                .AddCheck<DatabaseHealthCheck>("Database")
+                .AddCheck<NodeHealthCheck>("Nodes")
+                .AddCheck<DaemonHealthCheck>("Daemons");
 
             // Databases
             builder.Services.AddDbContext<DataContext>();
@@ -112,7 +118,6 @@ namespace Moonlight
             builder.Services.AddScoped<OneTimeJwtService>();
             builder.Services.AddSingleton<NotificationServerService>();
             builder.Services.AddScoped<NotificationAdminService>();
-            builder.Services.AddScoped<NotificationClientService>();
             builder.Services.AddScoped<ModalService>();
             builder.Services.AddScoped<SmartDeployService>();
             builder.Services.AddScoped<WebSpaceService>();
@@ -127,7 +132,8 @@ namespace Moonlight
             builder.Services.AddScoped<ReCaptchaService>();
             builder.Services.AddScoped<IpBanService>();
             builder.Services.AddSingleton<OAuth2Service>();
-            builder.Services.AddSingleton<BundleService>();
+            builder.Services.AddScoped<DynamicBackgroundService>();
+            builder.Services.AddScoped<ServerAddonPluginService>();
 
             builder.Services.AddScoped<SubscriptionService>();
             builder.Services.AddScoped<SubscriptionAdminService>();
@@ -155,6 +161,7 @@ namespace Moonlight
             builder.Services.AddSingleton<HostSystemHelper>();
             builder.Services.AddScoped<DaemonApiHelper>();
             builder.Services.AddScoped<CloudPanelApiHelper>();
+            builder.Services.AddScoped<ModrinthApiHelper>();
 
             // Background services
             builder.Services.AddSingleton<DiscordBotService>();
@@ -162,6 +169,9 @@ namespace Moonlight
             builder.Services.AddSingleton<DiscordNotificationService>();
             builder.Services.AddSingleton<CleanupService>();
             
+            // Other
+            builder.Services.AddSingleton<MoonlightService>();
+
             // Third party services
             builder.Services.AddBlazorTable();
             builder.Services.AddSweetAlert2(options => { options.Theme = SweetAlertTheme.Dark; });
@@ -186,6 +196,10 @@ namespace Moonlight
 
             app.MapBlazorHub();
             app.MapFallbackToPage("/_Host");
+            app.MapHealthChecks("/_health", new()
+            {
+                ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
+            });
 
             // AutoStart services
             _ = app.Services.GetRequiredService<CleanupService>();
@@ -193,6 +207,8 @@ namespace Moonlight
             _ = app.Services.GetRequiredService<StatisticsCaptureService>();
             _ = app.Services.GetRequiredService<DiscordNotificationService>();
             
+            _ = app.Services.GetRequiredService<MoonlightService>();
+
             // Discord bot service
             //var discordBotService = app.Services.GetRequiredService<DiscordBotService>();
 

Moonlight/Properties/launchSettings.json

@@ -1,18 +1,11 @@
 {
-  "iisSettings": {
-    "windowsAuthentication": false,
-    "anonymousAuthentication": true,
-    "iisExpress": {
-      "applicationUrl": "http://localhost:26548",
-      "sslPort": 44339
-    }
-  },
   "profiles": {
     "Moonlight": {
       "commandName": "Project",
       "launchBrowser": true,
       "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "ML_DEBUG": "true"
       },
       "applicationUrl": "http://moonlight.testy:5118;https://localhost:7118;http://localhost:5118",
       "dotnetRunMessages": true
@@ -22,7 +15,8 @@
       "launchBrowser": true,
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development",
-        "ML_SQL_DEBUG": "true"
+        "ML_SQL_DEBUG": "true",
+        "ML_DEBUG": "true"
       },
       "applicationUrl": "http://moonlight.testy:5118;https://localhost:7118;http://localhost:5118",
       "dotnetRunMessages": true
@@ -32,17 +26,11 @@
       "launchBrowser": false,
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development",
-        "ML_SQL_DEBUG": "true"
+        "ML_SQL_DEBUG": "true",
+        "ML_DEBUG": "true"
       },
       "applicationUrl": "http://moonlight.testy:5118;https://localhost:7118;http://localhost:5118",
       "dotnetRunMessages": true
-    },
-    "Docker": {
-      "commandName": "Docker",
-      "launchBrowser": false,
-      "launchUrl": "{Scheme}://{ServiceHost}:{ServicePort}",
-      "publishAllPorts": true,
-      "useSSL": true
     }
   }
 }

Moonlight/Shared/Components/ErrorBoundaries/SoftErrorBoundary.razor

@@ -3,10 +3,13 @@
 @using Moonlight.App.Services
 @using Logging.Net
 @using Moonlight.App.ApiClients.CloudPanel
+@using Moonlight.App.ApiClients.Daemon
+@using Moonlight.App.ApiClients.Modrinth
 @using Moonlight.App.ApiClients.Wings
 @inherits ErrorBoundaryBase
 
 @inject AlertService AlertService
+@inject ConfigService ConfigService
 @inject SmartTranslateService SmartTranslateService
 
 @if (Crashed)
@@ -36,16 +39,27 @@ else
     private bool Crashed = false;
     
     protected override async Task OnErrorAsync(Exception exception)
+    {
+        if (ConfigService.DebugMode)
         {
             Logger.Warn(exception);
+        }
         
         if (exception is DisplayException displayException)
+        {
+            if (displayException.DoNotTranslate)
+            {
+                await AlertService.Error(
+                    displayException.Message
+                    );
+            }
+            else
             {
                 await AlertService.Error(
-                SmartTranslateService.Translate("Error"),
                     SmartTranslateService.Translate(displayException.Message)
                     );
             }
+        }
         else if (exception is CloudflareException cloudflareException)
         {
             await AlertService.Error(
@@ -56,7 +70,7 @@ else
         else if (exception is WingsException wingsException)
         {
             await AlertService.Error(
-                SmartTranslateService.Translate("Error from daemon"),
+                SmartTranslateService.Translate("Error from wings"),
                 wingsException.Message
                 );
             
@@ -64,6 +78,22 @@ else
             
             Logger.Warn($"Wings exception status code: {wingsException.StatusCode}");
         }
+        else if (exception is DaemonException daemonException)
+        {
+            await AlertService.Error(
+                SmartTranslateService.Translate("Error from daemon"),
+                daemonException.Message
+                );
+
+            Logger.Warn($"Wings exception status code: {daemonException.StatusCode}");
+        }
+        else if (exception is ModrinthException modrinthException)
+        {
+            await AlertService.Error(
+                SmartTranslateService.Translate("Error from modrinth"),
+                modrinthException.Message
+                );
+        }
         else if (exception is CloudPanelException cloudPanelException)
         {
             await AlertService.Error(
@@ -77,6 +107,7 @@ else
         }
         else
         {
+            Logger.Warn(exception);
             Crashed = true;
             await InvokeAsync(StateHasChanged);
         }

Moonlight/Shared/Components/FileManagerPartials/FileManager.razor

@@ -185,6 +185,8 @@ else
                         await ToastService.Info(SmartTranslateService.Translate("Starting download"));
                     }
                 }
+                else
+                    await ToastService.Error(SmartTranslateService.Translate("You are not able to download folders using the moonlight file manager"));
             }
         });
         

Moonlight/Shared/Components/Navigations/AdminServersViewNavigation.razor

@@ -0,0 +1,51 @@
+@using Moonlight.App.Database.Entities
+<div class="card mb-5 mb-xl-10">
+    <div class="card-body pt-0 pb-0">
+        <ul class="nav nav-stretch nav-line-tabs nav-line-tabs-2x border-transparent fs-5 fw-bold">
+            <li class="nav-item mt-2">
+                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 0 ? "active" : "")" href="/admin/servers/view/@(Server.Id)">
+                    <TL>Overview</TL>
+                </a>
+            </li>
+            <li class="nav-item mt-2">
+                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 1 ? "active" : "")" href="/admin/servers/view/@(Server.Id)/image">
+                    <TL>Image</TL>
+                </a>
+            </li>
+            <li class="nav-item mt-2">
+                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 2 ? "active" : "")" href="/admin/servers/view/@(Server.Id)/resources">
+                    <TL>Resources</TL>
+                </a>
+            </li>
+            <li class="nav-item mt-2">
+                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 3 ? "active" : "")" href="/admin/servers/view/@(Server.Id)/allocations">
+                    <TL>Allocations</TL>
+                </a>
+            </li>
+            <li class="nav-item mt-2">
+                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 4 ? "active" : "")" href="/admin/servers/view/@(Server.Id)/archive">
+                    <TL>Archive</TL>
+                </a>
+            </li>
+            <li class="nav-item mt-2">
+                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 5 ? "active" : "")" href="/admin/servers/view/@(Server.Id)/debug">
+                    <TL>Debug</TL>
+                </a>
+            </li>
+            <li class="nav-item mt-2">
+                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 6 ? "active" : "")" href="/admin/servers/view/@(Server.Id)/delete">
+                    <TL>Delete</TL>
+                </a>
+            </li>
+        </ul>
+    </div>
+</div>
+
+@code
+{
+    [Parameter]
+    public int Index { get; set; }
+
+    [Parameter]
+    public Server Server { get; set; }
+}

Moonlight/Shared/Components/Navigations/ProfileNavigation.razor

@@ -31,12 +31,17 @@
                 </a>
             </li>
             <li class="nav-item mt-2">
-                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 1 ? "active" : "")" href="/profile/security">
+                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 1 ? "active" : "")" href="/profile/discord">
+                    <TL>Discord</TL>
+                </a>
+            </li>
+            <li class="nav-item mt-2">
+                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 2 ? "active" : "")" href="/profile/security">
                     <TL>Security</TL>
                 </a>
             </li>
             <li class="nav-item mt-2">
-                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 2 ? "active" : "")" href="/profile/subscriptions">
+                <a class="nav-link text-active-primary ms-0 me-10 py-5 @(Index == 3 ? "active" : "")" href="/profile/subscriptions">
                     <TL>Subscriptions</TL>
                 </a>
             </li>

Moonlight/Shared/Components/Partials/HealthCheckView.razor

@@ -0,0 +1,59 @@
+@using Moonlight.App.Models.Misc
+@using System.Text
+@using Moonlight.App.Helpers
+
+@{
+    string GetStatusColor(string s)
+    {
+        if (s == "Healthy")
+            return "success";
+        else if (s == "Unhealthy")
+            return "danger";
+        else
+            return "warning";
+    }
+}
+
+<div class="card">
+    <div class="card-header">
+        <div class="card-title">
+            <TL>Moonlight health</TL>:
+            <div class="ps-3 text-@(GetStatusColor(HealthCheck.Status))">
+                <TL>@(HealthCheck.Status)</TL>
+            </div>
+        </div>
+    </div>
+    <div class="card-body">
+        <div class="accordion" id="healthCheck">
+            @foreach (var entry in HealthCheck.Entries)
+            {
+                <div class="accordion-item">
+                    <h2 class="accordion-header" id="healthCheck_1_header_@(entry.Key.ToLower())">
+                        <button class="accordion-button fs-4 fw-semibold text-@(GetStatusColor(entry.Value.Status))" type="button" data-bs-toggle="collapse" data-bs-target="#healthCheck_body_@(entry.Key.ToLower())">
+                            @(entry.Key)
+                        </button>
+                    </h2>
+                    <div id="healthCheck_body_@(entry.Key.ToLower())" class="accordion-collapse collapse" data-bs-parent="#healthCheck">
+                        <div class="accordion-body">
+                            <b><TL>Status</TL>:</b>&nbsp;<TL>@(entry.Value.Status)</TL><br/>
+                            <b><TL>Description</TL>:</b>&nbsp;@(entry.Value.Description)<br/>
+                            <br/>
+                            @foreach (var x in entry.Value.Data)
+                            {
+                                <b>@(x.Key)</b>
+                                <br/>
+                                @(x.Value)<br/>
+                            }
+                        </div>
+                    </div>
+                </div>
+            }
+        </div>
+    </div>
+</div>
+
+@code
+{
+    [Parameter]
+    public HealthCheck HealthCheck { get; set; }
+}

Moonlight/Shared/Components/Router/Route.razor

@@ -0,0 +1,20 @@
+@{
+    var route = "/" + (Router.Route ?? "");
+}
+
+@if (route == Path)
+{
+    @ChildContent
+}
+
+@code
+{
+    [CascadingParameter]
+    public SmartRouter Router { get; set; }
+
+    [Parameter]
+    public RenderFragment ChildContent { get; set; }
+    
+    [Parameter]
+    public string Path { get; set; }
+}

Moonlight/Shared/Components/Router/SmartRouter.razor

@@ -0,0 +1,12 @@
+<CascadingValue TValue="SmartRouter" Value="@this">
+    @ChildContent
+</CascadingValue>
+
+@code
+{
+    [Parameter]
+    public string? Route { get; set; }
+
+    [Parameter]
+    public RenderFragment ChildContent { get; set; }
+}

Moonlight/Shared/Components/ServerControl/ServerAddons.razor

@@ -1,10 +0,0 @@
-<div class="alert alert-primary d-flex rounded p-6">
-    <div class="d-flex flex-stack flex-grow-1 flex-wrap flex-md-nowrap">
-        <div class="mb-3 mb-md-0 fw-semibold">
-            <h4 class="text-gray-900 fw-bold"><TL>Addons</TL></h4>
-            <div class="fs-6 text-gray-700 pe-7">
-                <TL>This feature is currently not available</TL>
-            </div>
-        </div>
-    </div>
-</div>

Moonlight/Shared/Components/WebsiteControl/WebSpaceDashboard.razor

@@ -10,7 +10,12 @@
     <div class="col-xl-4 mb-xl-10">
         <div class="card h-md-100">
             <div class="card-body d-flex flex-column flex-center">
-                <img class="img-fluid" src="https://shs.moonlightpanel.xyz/api/screenshot?url=http://@(CurrentWebSpace.Domain)" alt="Website screenshot"/>
+                <div class="position-relative" style="width: 100%; height: 0; padding-bottom: 56.25%;">
+                  <div class="position-absolute top-0 start-0 w-100 h-100 d-flex justify-content-center align-items-center">
+                      <img class="img-fluid" src="/assets/media/gif/loading.gif" alt="Placeholder" style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; object-fit: cover;">
+                    <div class="position-absolute top-0 start-0 w-100 h-100" style="background-image: url('https://shs.moonlightpanel.xyz/api/screenshot?url=http://@(CurrentWebSpace.Domain)'); background-size: cover; background-position: center;"></div>
+                  </div>
+                </div>
             </div>
         </div>
     </div>

Moonlight/Shared/Components/WebsiteControl/WebSpaceNavigation.razor

@@ -1,9 +1,16 @@
 @using Moonlight.App.Database.Entities
+@using Moonlight.App.Services
+@using Moonlight.App.Services.Interop
+
+@inject SmartTranslateService SmartTranslateService
+@inject WebSpaceService WebSpaceService
+@inject NavigationManager NavigationManager
+@inject AlertService AlertService
 
 <div class="card card-body">
     <div class="row">
-        <div class="col-8">
-            <div class="d-flex align-items-center">
+        <div class="d-flex justify-content-between">
+            <div class="d-flex">
                 <div class="symbol symbol-circle me-5">
                     <div class="symbol-label bg-transparent text-primary border border-secondary border-dashed">
                         <i class="bx bx-globe bx-md"></i>
@@ -14,13 +21,17 @@
                     <div class="text-muted fs-5">@(WebSpace.CloudPanel.Name)</div>
                 </div>
             </div>
+
+            <WButton Text="@(SmartTranslateService.Translate("Delete"))"
+                     WorkingText="@(SmartTranslateService.Translate("Deleting"))"
+                     OnClick="Delete"
+                     CssClasses="btn-danger">
+            </WButton>
         </div>
     </div>
 </div>
-<div class="row">
-    <div class="separator my-5"></div>
-</div>
-<div class="card mb-5 mb-xl-10">
+<div class="my-5"></div>
+<div class="card mb-xl-10 mb-5">
     <div class="card-body pt-0 pb-0">
         <ul class="nav nav-stretch nav-line-tabs nav-line-tabs-2x border-transparent fs-5 fw-bold">
             <li class="nav-item mt-2">
@@ -54,4 +65,13 @@
 
     [Parameter]
     public WebSpace WebSpace { get; set; }
+
+    private async Task Delete()
+    {
+        if (await AlertService.ConfirmMath())
+        {
+            await WebSpaceService.Delete(WebSpace);
+            NavigationManager.NavigateTo("/webspaces");
+        }
+    }
 }

Moonlight/Shared/Components/WebsiteControl/WebSpaceSftp.razor

@@ -22,7 +22,7 @@
                 </label>
             </div>
             <div class="col-md-9">
-                <input type="text" class="form-control form-control-solid disabled" disabled="disabled" value="21">
+                <input type="text" class="form-control form-control-solid disabled" disabled="disabled" value="22">
             </div>
         </div>
         <div class="row fv-row mb-7">

Moonlight/Shared/Components/Xterm/Terminal.razor

@@ -5,7 +5,7 @@
 <Xterm
     @ref="Xterm"
     Options="TerminalOptions"
-    AddonIds="@(new[] { "xterm-addon-fit", "xterm-addon-search", "xterm-addon-web-links" })"
+    AddonIds="@(new[] { "xterm-addon-fit" })"
     OnFirstRender="OnFirstRender">
 </Xterm>
 
@@ -48,6 +48,18 @@
         {
             await Xterm.InvokeAddonFunctionVoidAsync("xterm-addon-fit", "fit");
             RunOnFirstRender.Invoke();
+
+            await Task.Run(async () =>
+            {
+                try
+                {
+                    await Task.Delay(1000);
+                    await Xterm.InvokeAddonFunctionVoidAsync("xterm-addon-fit", "fit");
+                    await Task.Delay(1000);
+                    await Xterm.InvokeAddonFunctionVoidAsync("xterm-addon-fit", "fit");
+                }
+                catch (Exception){}
+            });
         }
         catch (Exception)
         {

Moonlight/Shared/Layouts/MainLayout.razor

@@ -20,9 +20,9 @@
 @inject ToastService ToastService
 @inject SmartTranslateService SmartTranslateService
 @inject IpBanService IpBanService
+@inject DynamicBackgroundService DynamicBackgroundService
 
-<GlobalErrorBoundary>
-    @{
+@{
     var uri = new Uri(NavigationManager.Uri);
     var pathParts = uri.LocalPath.Split("/").Reverse();
 
@@ -38,8 +38,9 @@
                 title += $"{pathPart.FirstCharToUpper()} - ";
         }
     }
-    }
+}
 
+<GlobalErrorBoundary>
     <CascadingValue Value="User">
         <PageTitle>@(string.IsNullOrEmpty(title) ? "Dashboard - " : title)Moonlight</PageTitle>
 
@@ -56,7 +57,7 @@
                     <Sidebar></Sidebar>
                     <div class="app-main flex-column flex-row-fluid" id="kt_app_main">
                         <div class="d-flex flex-column flex-column-fluid">
-                            <div id="kt_app_content" class="app-content flex-column-fluid">
+                            <div id="kt_app_content" class="app-content flex-column-fluid" style="background-position: center; background-size: cover; background-repeat: no-repeat; background-attachment: fixed; background-image: url('@(DynamicBackgroundService.BackgroundImageUrl)')">
                                 <div id="kt_app_content_container" class="app-container container-fluid">
                                     <div class="mt-10">
                                         <SoftErrorBoundary>
@@ -189,9 +190,11 @@
         {
             try
             {
+                DynamicBackgroundService.OnBackgroundImageChanged += async (_, _) => { await InvokeAsync(StateHasChanged); };
+
                 IsIpBanned = await IpBanService.IsBanned();
 
-                if(IsIpBanned)
+                if (IsIpBanned)
                     await InvokeAsync(StateHasChanged);
 
                 await Event.On<Object>("ipBan.update", this, async _ =>
@@ -211,7 +214,13 @@
 
                 await SessionService.Register();
 
-                NavigationManager.LocationChanged += (sender, args) => { SessionService.Refresh(); };
+                NavigationManager.LocationChanged += async (_, _) =>
+                {
+                    SessionService.Refresh();
+
+                    if (!NavigationManager.Uri.Contains("/server/"))
+                        await DynamicBackgroundService.Reset();
+                };
 
                 if (User != null)
                 {

Moonlight/Shared/Views/Admin/Index.razor

@@ -3,11 +3,16 @@
 @using Moonlight.App.Repositories
 @using Moonlight.App.Repositories.Domains
 @using Moonlight.App.Database.Entities
+@using Moonlight.App.Models.Misc
+@using Moonlight.App.Services
+@using Newtonsoft.Json
+@using Logging.Net
 
 @inject ServerRepository ServerRepository
 @inject UserRepository UserRepository
 @inject Repository<WebSpace> WebSpaceRepository
 @inject DomainRepository DomainRepository
+@inject ConfigService ConfigService
 
 <OnlyAdmin>
     <LazyLoader Load="Load">
@@ -97,6 +102,28 @@
                 </a>
             </div>
         </div>
+
+        <LazyLoader Load="LoadHealthCheckData">
+            @if (HealthCheckData == null)
+            {
+                <div class="card">
+                    <div class="card-header">
+                        <div class="card-title">
+                            <TL>Moonlight health</TL>
+                        </div>
+                    </div>
+                    <div class="card-body">
+                        <div class="alert alert-warning">
+                            <TL>Unable to fetch health check data</TL>
+                        </div>
+                    </div>
+                </div>
+            }
+            else
+            {
+                <HealthCheckView HealthCheck="@HealthCheckData"/>
+            }
+        </LazyLoader>
     </LazyLoader>
 </OnlyAdmin>
 
@@ -107,6 +134,8 @@
     private int DomainCount = 0;
     private int WebSpaceCount = 0;
 
+    private HealthCheck? HealthCheckData;
+
     private Task Load(LazyLoader lazyLoader)
     {
         ServerCount = ServerRepository.Get().Count();
@@ -116,4 +145,26 @@
 
         return Task.CompletedTask;
     }
+
+    private async Task LoadHealthCheckData(LazyLoader lazyLoader)
+    {
+        await lazyLoader.SetText("Loading health check data");
+
+        var appUrl = ConfigService
+            .GetSection("Moonlight")
+            .GetValue<string>("AppUrl");
+
+        try
+        {
+            using var client = new HttpClient();
+            var json = await client.GetStringAsync($"{appUrl}/_health");
+            HealthCheckData = JsonConvert.DeserializeObject<HealthCheck>(json) ?? new();
+        }
+        catch (Exception e)
+        {
+            HealthCheckData = null;
+            Logger.Warn("Unable to fetch health check data");
+            Logger.Warn(e);
+        }
+    }
 }

Moonlight/Shared/Views/Admin/Nodes/View.razor

@@ -41,7 +41,7 @@ else
                 </div>
                 <div class="m-0">
                     <span class="fw-bolder d-block fs-2qx lh-1 ls-n1 mb-1">
-                        @if (CpuStats == null)
+                        @if (CpuMetrics == null)
                         {
                             <span class="text-muted">
                                 <TL>Loading</TL>
@@ -50,12 +50,12 @@ else
                         else
                         {
                             <span>
-                                @(CpuStats.Usage)% <TL>of</TL> @(CpuStats.Cores) <TL>Cores used</TL>
+                                @(CpuMetrics.CpuUsage)% <TL>of CPU used</TL>
                             </span>
                         }
                     </span>
                     <span class="fw-semibold fs-6">
-                        @if (CpuStats == null)
+                        @if (CpuMetrics == null)
                         {
                             <span class="text-muted">
                                 <TL>Loading</TL>
@@ -63,7 +63,7 @@ else
                         }
                         else
                         {
-                            <span>@(CpuStats.Model)</span>
+                            <span>@(CpuMetrics.CpuModel)</span>
                         }
                     </span>
                 </div>
@@ -78,7 +78,7 @@ else
                 </div>
                 <div class="m-0">
                     <span class="fw-bolder d-block fs-2qx lh-1 ls-n1 mb-1">
-                        @if (MemoryStats == null)
+                        @if (MemoryMetrics == null)
                         {
                             <span class="text-muted">
                                 <TL>Loading</TL>
@@ -87,32 +87,12 @@ else
                         else
                         {
                             <span>
-                                @(Formatter.FormatSize(MemoryStats.Used * 1024D * 1024D)) <TL>of</TL> @(Formatter.FormatSize(MemoryStats.Total * 1024D * 1024D)) <TL>used</TL>
+                                @(Formatter.FormatSize(MemoryMetrics.Used)) <TL>of</TL> @(Formatter.FormatSize(MemoryMetrics.Total)) <TL>memory used</TL>
                             </span>
                         }
                     </span>
                     <span class="fw-semibold fs-6">
-                        @if (MemoryStats == null)
-                        {
-                            <span class="text-muted">
-                                <TL>Loading</TL>
-                            </span>
-                        }
-                        else
-                        {
-                            if (MemoryStats.Sticks.Any())
-                            {
-                                foreach (var stick in SortMemorySticks(MemoryStats.Sticks))
-                                {
-                                    <span>@(stick)</span>
-                                    <br/>
-                                }
-                            }
-                            else
-                            {
-                                <span>No memory sticks detected</span>
-                            }
-                        }
+                        @*IDK what to put here*@
                     </span>
                 </div>
             </div>
@@ -126,7 +106,7 @@ else
                 </div>
                 <div class="m-0">
                     <span class="fw-bolder d-block fs-2qx lh-1 ls-n1 mb-1">
-                        @if (DiskStats == null)
+                        @if (DiskMetrics == null)
                         {
                             <span class="text-muted">
                                 <TL>Loading</TL>
@@ -135,21 +115,12 @@ else
                         else
                         {
                             <span>
-                                @(Formatter.FormatSize(DiskStats.TotalSize - DiskStats.FreeBytes)) <TL>of</TL> @(Formatter.FormatSize(DiskStats.TotalSize)) <TL>used</TL>
+                                @(Formatter.FormatSize(DiskMetrics.Used)) <TL>of</TL> @(Formatter.FormatSize(DiskMetrics.Total)) <TL>used</TL>
                             </span>
                         }
                     </span>
                     <span class="fw-semibold fs-6">
-                        @if (DiskStats == null)
-                        {
-                            <span class="text-muted">
-                                <TL>Loading</TL>
-                            </span>
-                        }
-                        else
-                        {
-                            <span>@(DiskStats.Name) - @(DiskStats.DriveFormat)</span>
-                        }
+                        @*IDK what to put here*@
                     </span>
                 </div>
             </div>
@@ -239,7 +210,7 @@ else
                 </div>
                 <div class="m-0">
                     <span class="fw-bolder d-block fs-2qx lh-1 ls-n1 mb-1">
-                        @if (ContainerStats == null)
+                        @if (DockerMetrics == null)
                         {
                             <span class="text-muted">
                                 <TL>Loading</TL>
@@ -248,12 +219,12 @@ else
                         else
                         {
                             <span>
-                                <TL>@(ContainerStats.Containers.Count)</TL>
+                                <TL>@(DockerMetrics.Containers.Length)</TL>
                             </span>
                         }
                     </span>
                     <span class="fw-semibold fs-6">
-                        @if (ContainerStats == null)
+                        @if (DockerMetrics == null)
                         {
                             <span class="text-muted">
                                 <TL>Loading</TL>
@@ -290,11 +261,11 @@ else
 
     private Node? Node;
 
-    private CpuStats CpuStats;
-    private MemoryStats MemoryStats;
-    private DiskStats DiskStats;
+    private CpuMetrics CpuMetrics;
+    private MemoryMetrics MemoryMetrics;
+    private DiskMetrics DiskMetrics;
+    private DockerMetrics DockerMetrics;
     private SystemStatus SystemStatus;
-    private ContainerStats ContainerStats;
 
     private async Task Load(LazyLoader arg)
     {
@@ -311,16 +282,16 @@ else
                     SystemStatus = await NodeService.GetStatus(Node);
                     await InvokeAsync(StateHasChanged);
 
-                    CpuStats = await NodeService.GetCpuStats(Node);
+                    CpuMetrics = await NodeService.GetCpuMetrics(Node);
                     await InvokeAsync(StateHasChanged);
 
-                    MemoryStats = await NodeService.GetMemoryStats(Node);
+                    MemoryMetrics = await NodeService.GetMemoryMetrics(Node);
                     await InvokeAsync(StateHasChanged);
 
-                    DiskStats = await NodeService.GetDiskStats(Node);
+                    DiskMetrics = await NodeService.GetDiskMetrics(Node);
                     await InvokeAsync(StateHasChanged);
 
-                    ContainerStats = await NodeService.GetContainerStats(Node);
+                    DockerMetrics = await NodeService.GetDockerMetrics(Node);
                     await InvokeAsync(StateHasChanged);
                 }
                 catch (Exception e)
@@ -330,28 +301,4 @@ else
             });
         }
     }
-
-    private List<string> SortMemorySticks(List<MemoryStats.MemoryStick> sticks)
-    {
-    // Thank you ChatGPT <3
-
-        var groupedMemory = sticks.GroupBy(memory => new { memory.Type, memory.Size })
-            .Select(group => new
-            {
-                Type = group.Key.Type,
-                Size = group.Key.Size,
-                Count = group.Count()
-            });
-
-        var sortedMemory = groupedMemory.OrderBy(memory => memory.Type)
-            .ThenBy(memory => memory.Size);
-
-        List<string> sortedList = sortedMemory.Select(memory =>
-        {
-            string sizeString = $"{memory.Size}GB";
-            return $"{memory.Count}x {memory.Type} {sizeString}";
-        }).ToList();
-
-        return sortedList;
-    }
 }

Moonlight/Shared/Views/Admin/Notifications/Debugging.razor

@@ -0,0 +1,74 @@
+@page "/admin/notifications/debugging"
+@using Moonlight.App.Services.Notifications
+@using Moonlight.App.Models.Misc
+@using Moonlight.App.Events
+@using BlazorTable
+@using Moonlight.App.Database.Entities.Notification
+@using Moonlight.App.Services
+
+@inject NotificationServerService NotificationServerService
+@inject SmartTranslateService SmartTranslateService
+@inject EventSystem Event
+
+@implements IDisposable
+
+<OnlyAdmin>
+    <LazyLoader Load="Load">
+        <div class="card card-body">
+            <Table TableItem="ActiveNotificationClient" Items="Clients" PageSize="25" TableClass="table table-row-bordered table-row-gray-100 align-middle gs-0 gy-3" TableHeadClass="fw-bold text-muted">
+                <Column TableItem="ActiveNotificationClient" Title="@(SmartTranslateService.Translate("Id"))" Field="@(x => x.Client.Id)" Sortable="false" Filterable="true"/>
+                <Column TableItem="ActiveNotificationClient" Title="@(SmartTranslateService.Translate("User"))" Field="@(x => x.Client.User.Email)" Sortable="false" Filterable="true"/>
+                <Column TableItem="ActiveNotificationClient" Title="" Field="@(x => x.Client.Id)" Sortable="false" Filterable="false">
+                    <Template>
+                        <WButton Text="@(SmartTranslateService.Translate("Send notification"))"
+                                 WorkingText="@(SmartTranslateService.Translate("Working"))"
+                                 CssClasses="btn-primary"
+                                 OnClick="() => SendSampleNotification(context)">
+                        </WButton>
+                    </Template>
+                </Column>
+                <Pager ShowPageNumber="true" ShowTotalCount="true"/>
+            </Table>
+        </div>
+    </LazyLoader>
+</OnlyAdmin>
+
+
+@code
+{
+    private ActiveNotificationClient[] Clients;
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            await Event.On<NotificationClient>("notifications.addClient", this, async client =>
+            {
+                Clients = await NotificationServerService.GetActiveClients();
+                await InvokeAsync(StateHasChanged);
+            });
+
+            await Event.On<NotificationClient>("notifications.removeClient", this, async client =>
+            {
+                Clients = await NotificationServerService.GetActiveClients();
+                await InvokeAsync(StateHasChanged);
+            });
+        }
+    }
+
+    private async Task Load(LazyLoader loader)
+    {
+        Clients = await NotificationServerService.GetActiveClients();
+    }
+
+    private async Task SendSampleNotification(ActiveNotificationClient client)
+    {
+        await client.SendAction(@"{""action"": ""notify"",""notification"":{""id"":999,""channel"":""Sample Channel"",""content"":""This is a sample Notification"",""title"":""Sample Notification"",""url"":""server/9b724fe2-d882-49c9-8c34-3414c7e4a17e""}}");
+    }
+
+    public async void Dispose()
+    {
+        await Event.Off("notifications.addClient", this);
+        await Event.Off("notifications.removeClient", this);
+    }
+}