Merge pull request #135 from Moonlight-Panel/FixUnarchiveCrash

Fixed decompress issue (hopefully)

.github/workflows/test-docker-build.yml

@@ -0,0 +1,18 @@
+name: Test Build
+
+on:
+    push:
+        branches: [ "main" ]
+    pull_request:
+        types:
+            - closed
+        branches: [ "main" ]
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v2
+            - name: Build Docker image
+              run: docker build -t moonlightpanel/moonlight:${{ github.sha }} -f Moonlight/Dockerfile .

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,8 +89,7 @@ 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");
         });

Moonlight/App/Helpers/DatabaseCheckupService.cs

@@ -8,16 +8,22 @@ using MySql.Data.MySqlClient;
 
 namespace Moonlight.App.Helpers;
 
-public class DatabaseCheckup
+public class DatabaseCheckupService
 {
-    public static void Perform()
+    private readonly ConfigService ConfigService;
+
+    public DatabaseCheckupService(ConfigService configService)
     {
-        // This will also copy all default config files
-        var context = new DataContext(new ConfigService(new StorageService()));
+        ConfigService = configService;
+    }
+
+    public async Task Perform()
+    {
+        var context = new DataContext(ConfigService);
 
         Logger.Info("Checking database");
         
-        if (!context.Database.CanConnect())
+        if (!await context.Database.CanConnectAsync())
         {
             Logger.Fatal("-----------------------------------------------");
             Logger.Fatal("Unable to connect to mysql database");
@@ -32,19 +38,19 @@ public class DatabaseCheckup
 
         Logger.Info("Checking for pending migrations");
 
-        var migrations = context.Database
-            .GetPendingMigrations()
+        var migrations = (await context.Database
+            .GetPendingMigrationsAsync())
             .ToArray();
-        
+
         if (migrations.Any())
         {
             Logger.Info($"{migrations.Length} migrations pending. Updating now");
             
-            BackupDatabase();
+            await BackupDatabase();
             
             Logger.Info("Applying migrations");
             
-            context.Database.Migrate();
+            await context.Database.MigrateAsync();
             
             Logger.Info("Successfully applied migrations");
         }
@@ -54,7 +60,7 @@ public class DatabaseCheckup
         }
     }
 
-    public static void BackupDatabase()
+    public async Task BackupDatabase()
     {
         Logger.Info("Creating backup from database");
         
@@ -79,14 +85,14 @@ public class DatabaseCheckup
         var sw = new Stopwatch();
         sw.Start();
 
-        using MySqlConnection conn = new MySqlConnection(connectionString);
-        using MySqlCommand cmd = new MySqlCommand();
+        await using MySqlConnection conn = new MySqlConnection(connectionString);
+        await using MySqlCommand cmd = new MySqlCommand();
         using MySqlBackup mb = new MySqlBackup(cmd);
         
         cmd.Connection = conn;
-        conn.Open();
+        await conn.OpenAsync();
         mb.ExportToFile(file);
-        conn.Close();
+        await conn.CloseAsync();
 
         sw.Stop();
         Logger.Info($"Done. {sw.Elapsed.TotalSeconds}s");

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;
 
@@ -211,13 +212,27 @@ public class WingsFileAccess : FileAccess
 
     public override async Task Decompress(FileData fileData)
     {
-        var req = new DecompressFile()
+        try
         {
-            Root = CurrentPath,
-            File = fileData.Name
-        };
+            var req = new DecompressFile()
+            {
+                Root = CurrentPath,
+                File = fileData.Name
+            };
 
-        await WingsApiHelper.Post(Server.Node, $"api/servers/{Server.Uuid}/files/decompress", req);
+            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,7 +8,14 @@ public static class Formatter
     {
         TimeSpan t = TimeSpan.FromMilliseconds(uptime);
 
-        return $"{t.Hours}h {t.Minutes}m {t.Seconds}s";
+        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)

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,377 @@
+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":
+                        await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, "Jwt error detected",
+                            CancellationToken.None);
+                        
+                        await UpdateServerState(ServerState.Offline);
+                        await UpdateConsoleState(ConsoleState.Disconnected);
+
+                        await SaveMessage("Received a jwt error", true);
+                        break;
+
+                    case "token expired":
+                        await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, "Jwt error detected",
+                            CancellationToken.None);
+                        
+                        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 (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;
+
+        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;
+
+        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,20 +50,20 @@ public class WingsConsoleHelper
         }
     }
 
-    public string GenerateToken(Server server)
+    public async Task<string> GenerateToken(Server server)
     {
         var serverData = ServerRepository
             .Get()
             .Include(x => x.Node)
             .First(x => x.Id == server.Id);
-
+        
         var userid = 1;
         var secret = serverData.Node.Token;
         
 
         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

@@ -0,0 +1,149 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Moonlight.App.ApiClients.Wings;
+using Moonlight.App.ApiClients.Wings.Resources;
+using Moonlight.App.Database.Entities;
+using Moonlight.App.Http.Requests.DiscordBot.Requests;
+using Moonlight.App.Repositories;
+using Moonlight.App.Services;
+
+namespace Moonlight.App.Http.Controllers.Api.Moonlight;
+
+[ApiController]
+[Route("api/moonlight/discordbot")]
+public class DiscordBotController : Controller
+{
+    private readonly Repository<User> UserRepository;
+    private readonly Repository<Server> ServerRepository;
+    private readonly ServerService ServerService;
+    private readonly string Token = "";
+    private readonly bool Enable;
+
+    public DiscordBotController(
+        Repository<User> userRepository,
+        Repository<Server> serverRepository,
+        ServerService serverService,
+        ConfigService configService)
+    {
+        UserRepository = userRepository;
+        ServerRepository = serverRepository;
+        ServerService = serverService;
+
+        var config = configService
+            .GetSection("Moonlight")
+            .GetSection("DiscordBotApi");
+
+        Enable = config.GetValue<bool>("Enable");
+
+        if (Enable)
+        {
+            Token = config.GetValue<string>("Token");
+        }
+    }
+    
+    [HttpGet("{id}/link")]
+    public async Task<ActionResult> GetLink(ulong id)
+    {
+        if (!await IsAuth(Request))
+            return StatusCode(403);
+        
+        if (await GetUserFromDiscordId(id) == null)
+        {
+            return BadRequest();
+        }
+
+        return Ok();
+    }
+
+    [HttpGet("{id}/servers")]
+    public async Task<ActionResult<Server[]>> GetServers(ulong id)
+    {
+        if (!await IsAuth(Request))
+            return StatusCode(403);
+        
+        var user = await GetUserFromDiscordId(id);
+
+        if (user == null)
+            return BadRequest();
+
+        return ServerRepository
+            .Get()
+            .Include(x => x.Owner)
+            .Include(x => x.Image)
+            .Where(x => x.Owner.Id == user.Id)
+            .ToArray();
+    }
+
+    [HttpPost("{id}/servers/{uuid}")]
+    public async Task<ActionResult> SetPowerState(ulong id, Guid uuid, [FromBody] SetPowerSignal signal)
+    {
+        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)
+            .FirstOrDefault(x => x.Owner.Id == user.Id && x.Uuid == uuid);
+
+        if (server == null)
+            return NotFound();
+
+        if (Enum.TryParse(signal.Signal, true, out PowerSignal powerSignal))
+        {
+            await ServerService.SetPowerState(server, powerSignal);
+            return Ok();
+        }
+        else
+            return BadRequest();
+    }
+
+    [HttpGet("{id}/servers/{uuid}")]
+    public async Task<ActionResult<ServerDetails>> GetServerDetails(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)
+            .FirstOrDefault(x => x.Owner.Id == user.Id && x.Uuid == uuid);
+
+        if (server == null)
+            return NotFound();
+
+        return await ServerService.GetDetails(server);
+    }
+
+    private Task<User?> GetUserFromDiscordId(ulong discordId)
+    {
+        var user = UserRepository
+            .Get()
+            .FirstOrDefault(x => x.DiscordId == discordId);
+
+        return Task.FromResult(user);
+    }
+
+    private Task<bool> IsAuth(HttpRequest request)
+    {
+        if (!Enable)
+            return Task.FromResult(false);
+        
+        if (string.IsNullOrEmpty(request.Headers.Authorization))
+            return Task.FromResult(false);
+        
+        if(request.Headers.Authorization == Token)
+            return Task.FromResult(true);
+        
+        return Task.FromResult(false);
+    }
+}

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

@@ -1,10 +1,12 @@
-using Logging.Net;
+using System.Text;
+using Logging.Net;
 using Microsoft.AspNetCore.Mvc;
 using Moonlight.App.Helpers;
 using Moonlight.App.Models.Misc;
 using Moonlight.App.Services;
 using Moonlight.App.Services.Files;
 using Moonlight.App.Services.LogServices;
+using Moonlight.App.Services.Sessions;
 
 namespace Moonlight.App.Http.Controllers.Api.Moonlight;
 
@@ -14,12 +16,14 @@ public class ResourcesController : Controller
 {
     private readonly SecurityLogService SecurityLogService;
     private readonly BucketService BucketService;
+    private readonly BundleService BundleService;
 
     public ResourcesController(SecurityLogService securityLogService,
-        BucketService bucketService)
+        BucketService bucketService, BundleService bundleService)
     {
         SecurityLogService = securityLogService;
         BucketService = bucketService;
+        BundleService = bundleService;
     }
 
     [HttpGet("images/{name}")]
@@ -73,4 +77,34 @@ 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/Http/Requests/DiscordBot/Requests/SetPowerSignal.cs

@@ -0,0 +1,8 @@
+using Moonlight.App.ApiClients.Wings;
+
+namespace Moonlight.App.Http.Requests.DiscordBot.Requests;
+
+public class SetPowerSignal
+{
+    public string Signal { 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/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

@@ -8,6 +8,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;

Moonlight/App/Services/Sessions/BundleService.cs

@@ -0,0 +1,129 @@
+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/Dockerfile

@@ -20,6 +20,7 @@ FROM base AS final
 WORKDIR /app
 COPY --from=publish /app/publish .
 RUN mkdir -p /app/storage
+RUN touch /app/storage/donttriggeranyerrors
 RUN rm -r /app/storage/*
 COPY "Moonlight/defaultstorage" "/app/defaultstorage"
 ENTRYPOINT ["dotnet", "Moonlight.dll"]

Moonlight/Moonlight.csproj

@@ -41,7 +41,6 @@
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3-beta1" />
     <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" />

Moonlight/Pages/_Layout.cshtml

@@ -2,10 +2,12 @@
 @using Moonlight.App.Extensions
 @using Moonlight.App.Repositories
 @using Moonlight.App.Services
+@using Moonlight.App.Services.Sessions
 @namespace Moonlight.Pages
 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
 
 @inject ConfigService ConfigService
+@inject BundleService BundleService
 @inject LoadingMessageRepository LoadingMessageRepository
 
 @{
@@ -36,20 +38,29 @@
 
     <link rel="shortcut icon" href="@(moonlightConfig.GetValue<string>("AppUrl"))/api/moonlight/resources/images/logo.svg"/>
 
-    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Poppins:300,400,500,600,700"/>
-
-    <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"/>
+    @*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" 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"/>
+    
+    @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>
+            }
+        }
+    }
 
     <meta name="viewport" content="width=device-width, initial-scale=1"/>
     <base href="~/"/>
@@ -78,7 +89,7 @@
 
     @{
         string loadingMessage;
-        
+
         try
         {
             loadingMessage = LoadingMessageRepository.Get().Random().Message;
@@ -95,33 +106,24 @@
     </div>
 </div>
 
-<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/BlazorInputFile/inputfile.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.5.0/lib/xterm-addon-fit.min.js"></script>
-<script src="https://cdn.jsdelivr.net/npm/xterm-addon-search@0.8.2/lib/xterm-addon-search.min.js"></script>
-<script src="https://cdn.jsdelivr.net/npm/xterm-addon-web-links@0.5.0/lib/xterm-addon-web-links.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>
+@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>")
+        }
+    }
+}
 </body>
 </html>

Moonlight/Program.cs

@@ -9,6 +9,7 @@ using Moonlight.App.ApiClients.Wings;
 using Moonlight.App.Database;
 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;
@@ -33,17 +34,23 @@ namespace Moonlight
     {
         // App version. Change for release
         public static readonly string AppVersion = $"InDev {Formatter.FormatDateOnly(DateTime.Now.Date)}";
-        
-        public static void Main(string[] args)
+
+        public static async Task Main(string[] args)
         {
             Logger.UsedLogger = new CacheLogger();
-            
-            Logger.Info($"Working dir: {Directory.GetCurrentDirectory()}");
-            
-            DatabaseCheckup.Perform();
 
-            var builder = WebApplication.CreateBuilder(args);
+            Logger.Info($"Working dir: {Directory.GetCurrentDirectory()}");
+
+            Logger.Info("Running pre-init tasks");
             
+            // This will also copy all default config files
+            var configService = new ConfigService(new StorageService());
+            var databaseCheckupService = new DatabaseCheckupService(configService);
+                
+            await databaseCheckupService.Perform();
+            
+            var builder = WebApplication.CreateBuilder(args);
+
             // Switch to logging.net injection
             // TODO: Enable in production
             //builder.Logging.ClearProviders();
@@ -59,10 +66,10 @@ namespace Moonlight
                     options.HandshakeTimeout = TimeSpan.FromSeconds(10);
                 });
             builder.Services.AddHttpContextAccessor();
-            
+
             // Databases
             builder.Services.AddDbContext<DataContext>();
-            
+
             // Repositories
             builder.Services.AddSingleton<SessionRepository>();
             builder.Services.AddScoped<UserRepository>();
@@ -84,7 +91,7 @@ namespace Moonlight
             builder.Services.AddScoped<ErrorLogEntryRepository>();
             builder.Services.AddScoped<SecurityLogEntryRepository>();
             builder.Services.AddScoped(typeof(Repository<>));
-            
+
             // Services
             builder.Services.AddSingleton<ConfigService>();
             builder.Services.AddSingleton<StorageService>();
@@ -121,6 +128,7 @@ namespace Moonlight
             builder.Services.AddScoped<ReCaptchaService>();
             builder.Services.AddScoped<IpBanService>();
             builder.Services.AddSingleton<OAuth2Service>();
+            builder.Services.AddSingleton<BundleService>();
 
             builder.Services.AddScoped<SubscriptionService>();
             builder.Services.AddScoped<SubscriptionAdminService>();
@@ -148,7 +156,7 @@ namespace Moonlight
             builder.Services.AddSingleton<HostSystemHelper>();
             builder.Services.AddScoped<DaemonApiHelper>();
             builder.Services.AddScoped<CloudPanelApiHelper>();
-            
+
             // Background services
             builder.Services.AddSingleton<DiscordBotService>();
             builder.Services.AddSingleton<StatisticsCaptureService>();
@@ -176,7 +184,7 @@ namespace Moonlight
             app.UseWebSockets();
 
             app.MapControllers();
-            
+
             app.MapBlazorHub();
             app.MapFallbackToPage("/_Host");
 
@@ -185,11 +193,11 @@ namespace Moonlight
             _ = app.Services.GetRequiredService<DiscordBotService>();
             _ = app.Services.GetRequiredService<StatisticsCaptureService>();
             _ = app.Services.GetRequiredService<DiscordNotificationService>();
-            
+
             // Discord bot service
             //var discordBotService = app.Services.GetRequiredService<DiscordBotService>();
 
-            app.Run();
+            await app.RunAsync();
         }
     }
 }

Moonlight/Shared/Components/Navigations/ProfileNavigation.razor

@@ -9,7 +9,7 @@
                     <div class="d-flex flex-column">
                         <div class="d-flex align-items-center mb-2">
                             <a class="text-gray-900 fs-2 fw-bold me-1">@(User.FirstName) @(User.LastName)</a>
-                            
+
                             @if (User.Status == UserStatus.Verified)
                             {
                                 <i class="text-success bx bx-md bxs-badge-check"></i>
@@ -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/ServerControl/ServerBackups.razor

@@ -1,6 +1,4 @@
-@using PteroConsole.NET
-@using Moonlight.App.Services
-@using Task = System.Threading.Tasks.Task
+@using Moonlight.App.Services
 @using Moonlight.App.Helpers
 @using Logging.Net
 @using BlazorContextMenu
@@ -101,9 +99,6 @@
 
 @code
 {
-    [CascadingParameter]
-    public PteroConsole Console { get; set; }
-
     [CascadingParameter]
     public Server CurrentServer { get; set; }
 

Moonlight/Shared/Components/ServerControl/ServerConsole.razor

@@ -1,11 +1,9 @@
-@using PteroConsole.NET
-@using PteroConsole.NET.Enums
-@using Task = System.Threading.Tasks.Task
-@using Moonlight.App.Helpers
+@using Moonlight.App.Helpers
 @using Moonlight.App.Repositories
 @using Moonlight.App.Services
-@using Logging.Net
 @using Moonlight.App.Database.Entities
+@using Moonlight.App.Helpers.Wings
+@using Moonlight.App.Helpers.Wings.Data
 @using Moonlight.App.Services.Interop
 @using Moonlight.Shared.Components.Xterm
 
@@ -37,7 +35,7 @@
 @code
 {
     [CascadingParameter]
-    public PteroConsole Console { get; set; }
+    public WingsConsole Console { get; set; }
 
     [CascadingParameter]
     public Server CurrentServer { get; set; }
@@ -51,21 +49,35 @@
         Console.OnMessage += OnMessage;
     }
 
-    private async void OnMessage(object? sender, string e)
+    private async void OnMessage(object? sender, ConsoleMessage message)
     {
         if (Terminal != null)
         {
-            var s = e;
+            if (message.IsInternal)
+            {
+                await Terminal.WriteLine("\x1b[38;5;16;48;5;135m\x1b[39m\x1b[1m Moonlight \x1b[0m " + message.Content + "\x1b[0m");
+            }
+            else
+            {
+                var s = message.Content;
 
-            s = s.Replace("Pterodactyl Daemon", "Moonlight Daemon");
-            s = s.Replace("Checking server disk space usage, this could take a few seconds...", TranslationService.Translate("Checking disk space"));
-            s = s.Replace("Updating process configuration files...", TranslationService.Translate("Updating config files"));
-            s = s.Replace("Ensuring file permissions are set correctly, this could take a few seconds...", TranslationService.Translate("Checking file permissions"));
-            s = s.Replace("Pulling Docker container image, this could take a few minutes to complete...", TranslationService.Translate("Downloading server image"));
-            s = s.Replace("Finished pulling Docker container image", TranslationService.Translate("Downloaded server image"));
-            s = s.Replace("container@pterodactyl~", "server@moonlight >");
+                if (s.Contains("Moonlight Daemon") || s.Contains("Pterodactyl Daemon"))
+                {
+                    s = s.Replace("[39m", "\x1b[0m");
+                    s = s.Replace("[33m", "[38;5;16;48;5;135m\x1b[39m");
+                }
 
-            await Terminal.WriteLine(s);
+                s = s.Replace("[Pterodactyl Daemon]:", " Moonlight ");
+                s = s.Replace("[Moonlight Daemon]:", " Moonlight ");
+                s = s.Replace("Checking server disk space usage, this could take a few seconds...", TranslationService.Translate("Checking disk space"));
+                s = s.Replace("Updating process configuration files...", TranslationService.Translate("Updating config files"));
+                s = s.Replace("Ensuring file permissions are set correctly, this could take a few seconds...", TranslationService.Translate("Checking file permissions"));
+                s = s.Replace("Pulling Docker container image, this could take a few minutes to complete...", TranslationService.Translate("Downloading server image"));
+                s = s.Replace("Finished pulling Docker container image", TranslationService.Translate("Downloaded server image"));
+                s = s.Replace("container@pterodactyl~", "server@moonlight >");
+
+                await Terminal.WriteLine(s);
+            }
         }
     }
 
@@ -85,9 +97,9 @@
 
     private void RunOnFirstRender()
     {
-        lock (Console.MessageCache)
+        lock (Console.Messages)
         {
-            foreach (var message in Console.MessageCache.TakeLast(30))
+            foreach (var message in Console.Messages)
             {
                 OnMessage(null, message);
             }

Moonlight/Shared/Components/ServerControl/ServerFiles.razor

@@ -4,6 +4,7 @@
 @using Moonlight.App.Helpers.Files
 @using Moonlight.App.Services
 @using Moonlight.App.ApiClients.Wings
+@using Moonlight.App.Helpers.Wings
 
 @inject WingsApiHelper WingsApiHelper
 @inject WingsJwtHelper WingsJwtHelper

Moonlight/Shared/Components/ServerControl/ServerNavigation.razor

@@ -1,9 +1,8 @@
-@using PteroConsole.NET
-@using PteroConsole.NET.Enums
-@using Task = System.Threading.Tasks.Task
-@using Moonlight.App.Services
+@using Moonlight.App.Services
 @using Moonlight.App.Database.Entities
 @using Moonlight.App.Helpers
+@using Moonlight.App.Helpers.Wings
+@using Moonlight.App.Helpers.Wings.Enums
 
 @inject SmartTranslateService TranslationService
 
@@ -77,32 +76,32 @@
 
                                 case ServerState.Starting:
                                     <span class="text-warning"><TL>Starting</TL></span>
-                                    <span class="text-gray-700 pt-1 fw-semibold">(@(Formatter.FormatUptime(Console.ServerResource.Uptime)))</span>
+                                    <span class="text-gray-700 pt-1 fw-semibold">(@(Formatter.FormatUptime(Console.Resource.Uptime)))</span>
                                     break;
 
                                 case ServerState.Stopping:
                                     <span class="text-warning"><TL>Stopping</TL></span>
-                                    <span class="text-gray-700 pt-1 fw-semibold">(@(Formatter.FormatUptime(Console.ServerResource.Uptime)))</span>
+                                    <span class="text-gray-700 pt-1 fw-semibold">(@(Formatter.FormatUptime(Console.Resource.Uptime)))</span>
                                     break;
 
                                 case ServerState.Running:
                                     <span class="text-success"><TL>Online</TL></span>
-                                    <span class="text-gray-700 pt-1 fw-semibold">(@(Formatter.FormatUptime(Console.ServerResource.Uptime)))</span>
+                                    <span class="text-gray-700 pt-1 fw-semibold">(@(Formatter.FormatUptime(Console.Resource.Uptime)))</span>
                                     break;
                             }
                         </span>
                     </div>
                     <div class="col fs-5">
                         <span class="fw-bold"><TL>Cpu</TL>:</span>
-                        <span class="ms-1 text-muted">@(Math.Round(Console.ServerResource.CpuAbsolute, 2))%</span>
+                        <span class="ms-1 text-muted">@(Math.Round(Console.Resource.CpuAbsolute, 2))%</span>
                     </div>
                     <div class="col fs-5">
                         <span class="fw-bold"><TL>Memory</TL>:</span>
-                        <span class="ms-1 text-muted">@(Formatter.FormatSize(Console.ServerResource.MemoryBytes)) / @(Formatter.FormatSize(Console.ServerResource.MemoryLimitBytes))</span>
+                        <span class="ms-1 text-muted">@(Formatter.FormatSize(Console.Resource.MemoryBytes)) / @(Formatter.FormatSize(Console.Resource.MemoryLimitBytes))</span>
                     </div>
                     <div class="col fs-5">
                         <span class="fw-bold"><TL>Disk</TL>:</span>
-                        <span class="ms-1 text-muted">@(Formatter.FormatSize(Console.ServerResource.DiskBytes)) / @(Math.Round(CurrentServer.Disk / 1024f, 2)) GB</span>
+                        <span class="ms-1 text-muted">@(Formatter.FormatSize(Console.Resource.DiskBytes)) / @(Math.Round(CurrentServer.Disk / 1024f, 2)) GB</span>
                     </div>
                 </div>
             </div>
@@ -178,7 +177,7 @@
     public User User { get; set; }
 
     [CascadingParameter]
-    public PteroConsole Console { get; set; }
+    public WingsConsole Console { get; set; }
 
     [Parameter]
     public RenderFragment ChildContent { get; set; }
@@ -190,8 +189,8 @@
 
     protected override void OnInitialized()
     {
-        Console.OnServerStateUpdated += async (sender, state) => { await InvokeAsync(StateHasChanged); };
-        Console.OnServerResourceUpdated += async (sender, x) => { await InvokeAsync(StateHasChanged); };
+        Console.OnServerStateUpdated += async (_, _) => { await InvokeAsync(StateHasChanged); };
+        Console.OnResourceUpdated += async (_, _) => { await InvokeAsync(StateHasChanged); };
     }
 
     #region Power Actions

Moonlight/Shared/Layouts/MainLayout.razor

@@ -194,10 +194,10 @@
                 if(IsIpBanned)
                     await InvokeAsync(StateHasChanged);
                 
-                await Event.On<Object>("ipBan.update", this, async o =>
+                await Event.On<Object>("ipBan.update", this, async _ =>
                 {
                     IsIpBanned = await IpBanService.IsBanned();
-                    await InvokeAsync(StateHasChanged);
+                    NavigationManager.NavigateTo(NavigationManager.Uri, true);
                 });
 
                 User = await IdentityService.Get();

Moonlight/Shared/Views/Profile/Discord.razor

@@ -0,0 +1,77 @@
+@page "/profile/discord"
+
+@using Moonlight.Shared.Components.Navigations
+@using Moonlight.App.Database.Entities
+@using Moonlight.App.Repositories
+@using Moonlight.App.Services
+
+@inject Repository<User> UserRepository
+@inject SmartTranslateService SmartTranslateService
+
+<ProfileNavigation Index="1"/>
+
+@if (User.DiscordId == 0)
+{
+    <div class="row">
+        <div class="col">
+            <div class="alert bg-warning d-flex flex-column flex-sm-row p-5 mb-10">
+                <i class="fs-2hx text-light me-4 mb-5 mb-sm-0 bx bx-error bx-lg"></i>
+
+                <div class="d-flex flex-column text-light pe-0 pe-sm-10">
+                    <h4 class="mb-2 light">
+                        <TL>Your account is currently not linked to discord</TL>
+                    </h4>
+                    <TL>To use features like the discord bot, link your moonlight account with your discord account</TL><br/>
+                </div>
+            </div>
+        </div>
+
+        <div class="col">
+            <div class="card card-body">
+                <a class="btn btn-primary" href="/api/moonlight/oauth2/discord/start">
+                    <TL>Link account</TL>
+                </a>
+            </div>
+        </div>
+    </div>
+}
+else
+{
+    <div class="row">
+        <div class="col">
+            <div class="alert bg-success d-flex flex-column flex-sm-row p-5 mb-10">
+                <i class="fs-2hx text-light me-4 mb-5 mb-sm-0 bx bx-check bx-lg"></i>
+
+                <div class="d-flex flex-column text-light pe-0 pe-sm-10">
+                    <h4 class="mb-2 light">
+                        <TL>Your account is linked to a discord account</TL>
+                    </h4>
+                    <TL>You are able to use features like the discord bot of moonlight</TL>
+                </div>
+            </div>
+        </div>
+        <div class="col">
+            <div class="card card-body">
+                <WButton CssClasses="btn-danger"
+                         Text="@(SmartTranslateService.Translate("Remove link"))"
+                         WorkingText="@(SmartTranslateService.Translate("Working"))"
+                         OnClick="RemoveLink">
+                </WButton>
+            </div>
+        </div>
+    </div>
+}
+
+@code
+{
+    [CascadingParameter]
+    public User User { get; set; }
+
+    private async Task RemoveLink()
+    {
+        User.DiscordId = 0;
+        UserRepository.Update(User);
+
+        await InvokeAsync(StateHasChanged);
+    }
+}

Moonlight/Shared/Views/Profile/Security.razor

@@ -19,7 +19,7 @@
 @inject AlertService AlertService
 @inject ToastService ToastService
 
-<ProfileNavigation Index="1"/>
+<ProfileNavigation Index="2"/>
 
 <div class="card mb-5 mb-xl-10">
     <LazyLoader Load="Load">

Moonlight/Shared/Views/Profile/Subscriptions.razor

@@ -11,7 +11,7 @@
 @inject SubscriptionService SubscriptionService
 @inject SmartTranslateService SmartTranslateService
 
-<ProfileNavigation Index="2"/>
+<ProfileNavigation Index="3"/>
 
 <div class="card mb-3">
     <div class="row g-0">

Moonlight/Shared/Views/Server/Index.razor

@@ -1,13 +1,13 @@
 @page "/server/{ServerUuid}/{Route?}"
-@using PteroConsole.NET
 @using Task = System.Threading.Tasks.Task
 @using Moonlight.App.Repositories.Servers
-@using PteroConsole.NET.Enums
 @using Microsoft.EntityFrameworkCore
 @using Logging.Net
 @using Moonlight.App.Database.Entities
 @using Moonlight.App.Events
 @using Moonlight.App.Helpers
+@using Moonlight.App.Helpers.Wings
+@using Moonlight.App.Helpers.Wings.Enums
 @using Moonlight.App.Repositories
 @using Moonlight.App.Services
 @using Moonlight.Shared.Components.Xterm
@@ -44,7 +44,7 @@
     {
         if (NodeOnline)
         {
-            if (Console.ConnectionState == ConnectionState.Connected)
+            if (Console.ConsoleState == ConsoleState.Connected)
             {
                 if (Console.ServerState == ServerState.Installing)
                 {
@@ -179,7 +179,7 @@
     [Parameter]
     public string? Route { get; set; }
 
-    private PteroConsole? Console;
+    private WingsConsole? Console;
     private Server? CurrentServer;
     private Node Node;
     private bool NodeOnline = false;
@@ -193,11 +193,11 @@
     {
         Console = new();
 
-        Console.OnConnectionStateUpdated += (_, _) => { InvokeAsync(StateHasChanged); };
-        Console.OnServerResourceUpdated += async (_, _) => { await InvokeAsync(StateHasChanged); };
-        Console.OnServerStateUpdated += async (_, _) => { await InvokeAsync(StateHasChanged); };
+        Console.OnConsoleStateUpdated += (_, _) => { InvokeAsync(StateHasChanged); };
+        Console.OnResourceUpdated += (_, _) => { InvokeAsync(StateHasChanged); };
+        Console.OnServerStateUpdated += (_, _) => { InvokeAsync(StateHasChanged); };
 
-        Console.RequestToken += (_) => WingsConsoleHelper.GenerateToken(CurrentServer!);
+        Console.OnRequestNewToken += async _ => await WingsConsoleHelper.GenerateToken(CurrentServer!);
 
         Console.OnMessage += async (_, s) =>
         {
@@ -205,7 +205,10 @@
             {
                 if (InstallConsole != null)
                 {
-                    await InstallConsole.WriteLine(s);
+                    if (s.IsInternal)
+                        await InstallConsole.WriteLine("\x1b[38;5;16;48;5;135m\x1b[39m\x1b[1m Moonlight \x1b[0m " + s.Content + "\x1b[0m");
+                    else
+                        await InstallConsole.WriteLine(s.Content);
                 }
             }
         };
@@ -280,7 +283,7 @@
 
                 await lazyLoader.SetText("Connecting to console");
 
-                await WingsConsoleHelper.ConnectWings(Console!, CurrentServer);
+                await ReconnectConsole();
 
                 await Event.On<Server>($"server.{CurrentServer.Uuid}.installComplete", this, server =>
                 {
@@ -295,6 +298,12 @@
             Logger.Debug("Server is null");
         }
     }
+    
+    private async Task ReconnectConsole()
+    {
+        await Console!.Disconnect();
+        await WingsConsoleHelper.ConnectWings(Console!, CurrentServer!);
+    }
 
     public async void Dispose()
     {

Moonlight/Shared/Views/Servers/Index.razor

@@ -1,5 +1,4 @@
 @page "/servers"
-@using Moonlight.App.Services.Sessions
 @using Moonlight.App.Repositories.Servers
 @using Microsoft.EntityFrameworkCore
 @using Moonlight.App.Database.Entities
@@ -9,9 +8,97 @@
 @inject IServiceScopeFactory ServiceScopeFactory
 
 <LazyLoader Load="Load">
-    @if (AllServers.Any())
+@if (AllServers.Any())
+{
+    if (UseSortedServerView)
     {
-        @foreach (var server in AllServers)
+        var groupedServers = AllServers
+            .OrderBy(x => x.Name)
+            .GroupBy(x => x.Image.Name);
+
+        foreach (var groupedServer in groupedServers)
+        {
+            <div class="separator separator-content my-15">@(groupedServer.Key)</div>
+            <div class="card card-body bg-secondary py-0 my-0 mx-0 px-0">
+                @foreach (var server in groupedServer)
+                {
+                    <div class="row mx-4 my-4">
+                            <a class="card card-body" href="/server/@(server.Uuid)">
+                                <div class="row">
+                                    <div class="col">
+                                        <div class="d-flex align-items-center">
+                                            <div class="symbol symbol-50px me-3">
+                                                <i class="bx bx-md bx-server"></i>
+                                            </div>
+                                            <div class="d-flex justify-content-start flex-column">
+                                                <a href="/server/@(server.Uuid)" class="text-gray-800 text-hover-primary mb-1 fs-5">
+                                                    @(server.Name)
+                                                </a>
+                                                <span class="text-gray-400 fw-semibold d-block fs-6">
+                                                    @(Math.Round(server.Memory / 1024D, 2)) GB / @(Math.Round(server.Disk / 1024D, 2)) GB / @(server.Node.Name) <span class="text-gray-700">- @(server.Image.Name)</span>
+                                                </span>
+                                            </div>
+                                        </div>
+                                    </div>
+                                    <div class="d-none d-sm-block col my-auto fs-6">
+                                        @(server.Node.Fqdn):@(server.MainAllocation.Port)
+                                    </div>
+                                    <div class="d-none d-sm-block col my-auto fs-6">
+                                        @if (StatusCache.ContainsKey(server))
+                                        {
+                                            var status = StatusCache[server];
+
+                                            switch (status)
+                                            {
+                                                case "offline":
+                                                    <span class="text-danger">
+                                                        <TL>Offline</TL>
+                                                    </span>
+                                                    break;
+                                                case "stopping":
+                                                    <span class="text-warning">
+                                                        <TL>Stopping</TL>
+                                                    </span>
+                                                    break;
+                                                case "starting":
+                                                    <span class="text-warning">
+                                                        <TL>Starting</TL>
+                                                    </span>
+                                                    break;
+                                                case "running":
+                                                    <span class="text-success">
+                                                        <TL>Running</TL>
+                                                    </span>
+                                                    break;
+                                                case "failed":
+                                                    <span class="text-gray-400">
+                                                        <TL>Failed</TL>
+                                                    </span>
+                                                    break;
+                                                default:
+                                                    <span class="text-danger">
+                                                        <TL>Offline</TL>
+                                                    </span>
+                                                    break;
+                                            }
+                                        }
+                                        else
+                                        {
+                                            <span class="text-gray-400">
+                                                <TL>Loading</TL>
+                                            </span>
+                                        }
+                                    </div>
+                                </div>
+                            </a>
+                        </div>
+                }
+            </div>
+        }
+    }
+    else
+    {
+        foreach (var server in AllServers)
         {
             <div class="row px-5 mb-5">
                 <a class="card card-body" href="/server/@(server.Uuid)">
@@ -42,28 +129,42 @@
                                 switch (status)
                                 {
                                     case "offline":
-                                        <span class="text-danger"><TL>Offline</TL></span>
+                                        <span class="text-danger">
+                                            <TL>Offline</TL>
+                                        </span>
                                         break;
                                     case "stopping":
-                                        <span class="text-warning"><TL>Stopping</TL></span>
+                                        <span class="text-warning">
+                                            <TL>Stopping</TL>
+                                        </span>
                                         break;
                                     case "starting":
-                                        <span class="text-warning"><TL>Starting</TL></span>
+                                        <span class="text-warning">
+                                            <TL>Starting</TL>
+                                        </span>
                                         break;
                                     case "running":
-                                        <span class="text-success"><TL>Running</TL></span>
+                                        <span class="text-success">
+                                            <TL>Running</TL>
+                                        </span>
                                         break;
                                     case "failed":
-                                        <span class="text-gray-400"><TL>Failed</TL></span>
+                                        <span class="text-gray-400">
+                                            <TL>Failed</TL>
+                                        </span>
                                         break;
                                     default:
-                                        <span class="text-danger"><TL>Offline</TL></span>
+                                        <span class="text-danger">
+                                            <TL>Offline</TL>
+                                        </span>
                                         break;
                                 }
                             }
                             else
                             {
-                                <span class="text-gray-400"><TL>Loading</TL></span>
+                                <span class="text-gray-400">
+                                    <TL>Loading</TL>
+                                </span>
                             }
                         </div>
                     </div>
@@ -71,29 +172,53 @@
             </div>
         }
     }
-    else
-    {
-        <div class="alert bg-info d-flex flex-column flex-sm-row w-100 p-5">
-            <div class="d-flex flex-column pe-0 pe-sm-10">
-                <h4 class="fw-semibold">
-                    <TL>You have no servers</TL>
-                </h4>
-                <span>
-                    <TL>We were not able to find any servers associated with your account</TL>
-                </span>
+}
+else
+{
+    <div class="alert bg-info d-flex flex-column flex-sm-row w-100 p-5">
+        <div class="d-flex flex-column pe-0 pe-sm-10">
+            <h4 class="fw-semibold">
+                <TL>You have no servers</TL>
+            </h4>
+            <span>
+                <TL>We were not able to find any servers associated with your account</TL>
+            </span>
+        </div>
+    </div>
+}
+
+<div class="row mt-7 px-3">
+    <div class="card">
+        <div class="card-header">
+            <div class="card-title">
+                <span class="badge badge-primary badge-lg">Beta</span>
             </div>
         </div>
-    }
+        <div class="card-body">
+            <div class="row">
+                <label class="col-lg-4 col-form-label fw-semibold fs-6">Sorted server view</label>
+                <div class="col-lg-8 d-flex align-items-center">
+                    <div class="form-check form-check-solid form-switch form-check-custom fv-row">
+                        <input class="form-check-input w-45px h-30px" type="checkbox" id="sortedServerView" @bind="UseSortedServerView">
+                        <label class="form-check-label" for="sortedServerView"></label>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
 </LazyLoader>
 
 @code
 {
     [CascadingParameter]
     public User User { get; set; }
-    
+
     private Server[] AllServers;
     private readonly Dictionary<Server, string> StatusCache = new();
 
+    private bool UseSortedServerView = false;
+
     private Task Load(LazyLoader arg)
     {
         AllServers = ServerRepository
@@ -123,11 +248,11 @@
                 }
             });
         }
-        
+
         return Task.CompletedTask;
     }
 
-    private void AddStatus(App.Database.Entities.Server server, string status)
+    private void AddStatus(Server server, string status)
     {
         lock (StatusCache)
         {

Moonlight/defaultstorage/configs/config.json

@@ -8,6 +8,10 @@
       "Port": "10324",
       "Username": "user_name"
     },
+    "DiscordBotApi": {
+      "Enable": false,
+      "Token": "you api key here"
+    },
     "DiscordBot": {
       "Enable": false,
       "Token": "Discord.Token.Here",