From c600e51164e49df2700543cc205cb651e454c475 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Thu, 29 Jun 2023 11:33:49 +0200
Subject: [PATCH 01/22] begin startup overhaul

---
 .../Attributes/CliCommandAttribute.cs         |   6 -
 .../Attributes/CliOptionAttribute.cs          |  23 ---
 .../Attributes/RequiredFeaturesAttribute.cs   |  26 +++
 src/EvoSC.CLI/BaseStartup.cs                  | 188 ++++++++++++++++++
 src/EvoSC.CLI/CliCommandContext.cs            |   9 -
 src/EvoSC.CLI/CliHandler.cs                   |  88 --------
 src/EvoSC.CLI/CliManager.cs                   | 134 +++++++++++++
 src/EvoSC.CLI/EvoSC.CLI.csproj                |   3 +
 .../Exceptions/CliCommandAttributeNotFound.cs |   9 -
 src/EvoSC.CLI/Exceptions/EvoSCCliException.cs |  21 --
 src/EvoSC.CLI/Interfaces/ICliCommand.cs       |  12 --
 src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs   |  15 ++
 src/EvoSC.CLI/Interfaces/ICliManager.cs       |   9 +
 src/EvoSC.CLI/Models/CliCommandInfo.cs        |  15 ++
 src/EvoSC.CLI/Models/CliEvoScConfig.cs        |   8 +
 src/EvoSC.CLI/Models/CliEvoScConfigBinder.cs  |  15 ++
 src/EvoSC.Common/Application/AppFeature.cs    |  24 +++
 .../Application/ServicesBuilder.cs            |  11 +
 .../Application/StartupPipeline.cs            |  44 ++++
 .../Config/ConfigServiceExtensions.cs         |  41 ----
 src/EvoSC.Common/Config/Configuration.cs      |  37 ++++
 ...TomlMappingManaager.cs => ConfigMapper.cs} |   6 +-
 .../Config/Stores/EvoSCBaseConfigStore.cs     |  47 +++++
 .../Config/Stores/StoreExtensions.cs          |   6 +-
 .../Config/Stores/TomlConfigStore.cs          |   1 +
 .../Extensions/DatabaseServiceExtensions.cs   |   7 +-
 .../Interfaces/IEvoSCApplication.cs           |   2 +
 .../Interfaces/IStartupPipeline.cs            |  25 +++
 src/EvoSC/Application.cs                      |  59 ++++--
 src/EvoSC/CliCommands/RunCommand.cs           |  20 +-
 src/EvoSC/EvoSC.csproj                        |   4 +
 src/EvoSC/Program.cs                          |   8 +-
 tests/EvoSC.CLI.Tests/CliHandlerTests.cs      |  40 ----
 .../TestFiles/ConfigTests.cs                  |  13 --
 34 files changed, 675 insertions(+), 301 deletions(-)
 delete mode 100644 src/EvoSC.CLI/Attributes/CliOptionAttribute.cs
 create mode 100644 src/EvoSC.CLI/Attributes/RequiredFeaturesAttribute.cs
 create mode 100644 src/EvoSC.CLI/BaseStartup.cs
 delete mode 100644 src/EvoSC.CLI/CliCommandContext.cs
 delete mode 100644 src/EvoSC.CLI/CliHandler.cs
 create mode 100644 src/EvoSC.CLI/CliManager.cs
 delete mode 100644 src/EvoSC.CLI/Exceptions/CliCommandAttributeNotFound.cs
 delete mode 100644 src/EvoSC.CLI/Exceptions/EvoSCCliException.cs
 delete mode 100644 src/EvoSC.CLI/Interfaces/ICliCommand.cs
 create mode 100644 src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs
 create mode 100644 src/EvoSC.CLI/Interfaces/ICliManager.cs
 create mode 100644 src/EvoSC.CLI/Models/CliCommandInfo.cs
 create mode 100644 src/EvoSC.CLI/Models/CliEvoScConfig.cs
 create mode 100644 src/EvoSC.CLI/Models/CliEvoScConfigBinder.cs
 create mode 100644 src/EvoSC.Common/Application/AppFeature.cs
 create mode 100644 src/EvoSC.Common/Application/ServicesBuilder.cs
 create mode 100644 src/EvoSC.Common/Application/StartupPipeline.cs
 delete mode 100644 src/EvoSC.Common/Config/ConfigServiceExtensions.cs
 create mode 100644 src/EvoSC.Common/Config/Configuration.cs
 rename src/EvoSC.Common/Config/Mapping/Toml/{TomlMappingManaager.cs => ConfigMapper.cs} (61%)
 create mode 100644 src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
 create mode 100644 src/EvoSC.Common/Interfaces/IStartupPipeline.cs

diff --git a/src/EvoSC.CLI/Attributes/CliCommandAttribute.cs b/src/EvoSC.CLI/Attributes/CliCommandAttribute.cs
index b7c454dcc..014b7d3c6 100644
--- a/src/EvoSC.CLI/Attributes/CliCommandAttribute.cs
+++ b/src/EvoSC.CLI/Attributes/CliCommandAttribute.cs
@@ -3,12 +3,6 @@
 [AttributeUsage(AttributeTargets.Class)]
 public class CliCommandAttribute : Attribute
 {
-    /// <summary>
-    /// The name of the command.
-    /// </summary>
     public required string Name { get; init; }
-    /// <summary>
-    /// Description of the command.
-    /// </summary>
     public required string Description { get; init; }
 }
diff --git a/src/EvoSC.CLI/Attributes/CliOptionAttribute.cs b/src/EvoSC.CLI/Attributes/CliOptionAttribute.cs
deleted file mode 100644
index c26761295..000000000
--- a/src/EvoSC.CLI/Attributes/CliOptionAttribute.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-namespace EvoSC.CLI.Attributes;
-
-[AttributeUsage(AttributeTargets.Class)]
-public class CliOptionAttribute : Attribute
-{
-    public string[] Aliases { get; }
-    public string Description { get; }
-    public Type TOption { get; }
-    
-    public CliOptionAttribute(Type tOption, string name, string description)
-    {
-        Aliases = new[] {name};
-        TOption = tOption;
-        Description = description;
-    }
-    
-    public CliOptionAttribute(Type tOption, string description, params string[] aliases)
-    {
-        Aliases = aliases;
-        Description = description;
-        TOption = tOption;
-    }
-}
diff --git a/src/EvoSC.CLI/Attributes/RequiredFeaturesAttribute.cs b/src/EvoSC.CLI/Attributes/RequiredFeaturesAttribute.cs
new file mode 100644
index 000000000..c459c7921
--- /dev/null
+++ b/src/EvoSC.CLI/Attributes/RequiredFeaturesAttribute.cs
@@ -0,0 +1,26 @@
+using EvoSC.Common.Application;
+
+namespace EvoSC.CLI.Attributes;
+
+[AttributeUsage(AttributeTargets.Class)]
+public class RequiredFeaturesAttribute :  Attribute
+{
+    public AppFeature[] Features { get; init; }
+
+    public RequiredFeaturesAttribute(AppFeature feature, params AppFeature[] features)
+    {
+        var requiredFeatures = new List<AppFeature>();
+        
+        if (feature == AppFeature.All)
+        {
+            requiredFeatures.AddRange(Enum.GetValues<AppFeature>().Where(f => f != AppFeature.All));
+        }
+        else
+        {
+            requiredFeatures.Add(feature);
+            requiredFeatures.AddRange(features);
+        }
+
+        Features = requiredFeatures.ToArray();
+    }
+}
diff --git a/src/EvoSC.CLI/BaseStartup.cs b/src/EvoSC.CLI/BaseStartup.cs
new file mode 100644
index 000000000..aef2e89ce
--- /dev/null
+++ b/src/EvoSC.CLI/BaseStartup.cs
@@ -0,0 +1,188 @@
+using EvoSC.Commands;
+using EvoSC.Commands.Interfaces;
+using EvoSC.Common.Application;
+using EvoSC.Common.Config.Models;
+using EvoSC.Common.Controllers;
+using EvoSC.Common.Database;
+using EvoSC.Common.Database.Extensions;
+using EvoSC.Common.Events;
+using EvoSC.Common.Interfaces;
+using EvoSC.Common.Interfaces.Controllers;
+using EvoSC.Common.Interfaces.Middleware;
+using EvoSC.Common.Interfaces.Services;
+using EvoSC.Common.Logging;
+using EvoSC.Common.Middleware;
+using EvoSC.Common.Permissions;
+using EvoSC.Common.Remote;
+using EvoSC.Common.Services;
+using EvoSC.Manialinks;
+using EvoSC.Manialinks.Interfaces;
+using EvoSC.Modules.Extensions;
+using EvoSC.Modules.Interfaces;
+using EvoSC.Modules.Util;
+using SimpleInjector;
+
+namespace EvoSC.CLI;
+
+public static class BaseStartup
+{
+    public static void SetupBasePipeline(this IStartupPipeline pipeline, IEvoScBaseConfig config)
+    {
+        pipeline
+            .Services(AppFeature.Logging, s => s.AddEvoScLogging(config.Logging))
+
+            .Services(AppFeature.DatabaseMigrations, s => s.AddEvoScMigrations())
+
+            .Services(AppFeature.Database, s => s
+                .DependsOn("DatabaseMigrations")
+                .AddEvoScDatabase(config.Database)
+            )
+
+            .Services(AppFeature.Events, s => s.AddEvoScEvents())
+
+            .Services(AppFeature.GbxRemoteClient, s => s.AddGbxRemoteClient())
+
+            .Services(AppFeature.Modules, s => s.AddEvoScModules())
+
+            .Services(AppFeature.ControllerManager, s => s.AddEvoScControllers())
+
+            .Services(AppFeature.PlayerManager, s => s
+                .Register<IPlayerManagerService, PlayerManagerService>(Lifestyle.Transient)
+            )
+
+            .Services(AppFeature.MapsManager, s => s
+                .Register<IMapService, MapService>(Lifestyle.Transient)
+            )
+
+            .Services(AppFeature.PlayerCache, s => s
+                .RegisterSingleton<IPlayerCacheService, PlayerCacheService>()
+            )
+
+            .Services(AppFeature.MatchSettings, s => s
+                .Register<IMatchSettingsService, MatchSettingsService>(Lifestyle.Transient)
+            )
+
+            .Services(AppFeature.Auditing, s => s
+                .Register<IAuditService, AuditService>(Lifestyle.Transient)
+            )
+
+            .Services(AppFeature.ServicesManager, s => s
+                .RegisterSingleton<IServiceContainerManager, ServiceContainerManager>()
+            )
+
+            .Services(AppFeature.ChatCommands, s => s.AddEvoScChatCommands())
+
+            .Services(AppFeature.ActionPipelines, s => s.AddEvoScMiddlewarePipelines())
+
+            .Services(AppFeature.Permissions, s => s.AddEvoScPermissions())
+
+            .Services(AppFeature.Manialinks, s => s.AddEvoScManialinks())
+
+            .Action("ActionMigrateDatabase", MigrateDatabase)
+
+            .Action("ActionSetupControllerManager", SetupControllerManager)
+
+            .ActionAsync("ActionSetupModules", SetupModules)
+
+            .Action("ActionInitializeEventManager", s => s
+                .DependsOn("Events")
+                .GetInstance<IEventManager>()
+            )
+
+            .Action("ActionInitializePlayerCache", s => s
+                .DependsOn("PlayerCache")
+                .GetInstance<IPlayerCacheService>()
+            )
+
+            .Action("ActionInitializeManialinkInteractionHandler", s => s
+                .DependsOn("ActionInitializeEventManager", "ActionInitializePlayerCache")
+            )
+            
+            .ActionAsync("InitializeGbxRemoteConnection", SetupGbxRemoteConnection)
+            
+            .ActionAsync("ActionEnableModules", EnableModules)
+            
+            .ActionAsync("ActionInitializeTemplates", InitializeTemplates);
+    }
+    
+    private static async Task InitializeTemplates(ServicesBuilder s)
+    {
+        s.DependsOn("Manialinks");
+    
+        var maniaLinks = s.GetInstance<IManialinkManager>();
+        await maniaLinks.PreprocessAllAsync();
+    }
+
+    private static async Task EnableModules(ServicesBuilder s)
+    {
+        await s.GetInstance<IManialinkManager>().AddDefaultTemplatesAsync();
+        await s.GetInstance<IModuleManager>().EnableModulesAsync();
+    }
+
+    private static void MigrateDatabase(ServicesBuilder s)
+    {
+        s.DependsOn("DatabaseMigrations");
+        using var scope = new Scope(s);
+        var manager = scope.GetInstance<IMigrationManager>();
+    
+        // main migrations
+        manager.MigrateFromAssembly(typeof(MigrationManager).Assembly);
+    
+        // internal modules
+        // manager.RunInternalModuleMigrations();
+    }
+
+    private static void SetupControllerManager(ServicesBuilder s)
+    {
+        s.DependsOn("ControllerManager", "ActionPipelines");
+
+        var controllers = s.GetInstance<IControllerManager>();
+        controllers.AddControllerActionRegistry(s.GetInstance<IEventManager>());
+        controllers.AddControllerActionRegistry(s.GetInstance<IChatCommandManager>());
+        controllers.AddControllerActionRegistry(s.GetInstance<IManialinkActionManager>());
+    
+        var pipelineManager = s.GetInstance<IActionPipelineManager>();
+        pipelineManager.UseEvoScCommands(s);
+        pipelineManager.UseEvoScManialinks(s);
+    }
+
+    private static async Task SetupModules(ServicesBuilder s)
+    {
+        s.DependsOn("Modules", "Config");
+
+        var modules = s.GetInstance<IModuleManager>();
+        var config = s.GetInstance<IEvoScBaseConfig>();
+
+        // await modules.LoadInternalModulesAsync();
+
+        var dirs = config.Modules.ModuleDirectories;
+        var externalModules = new SortedModuleCollection<IExternalModuleInfo>();
+        foreach (var dir in dirs)
+        {
+            if (!Directory.Exists(dir))
+            {
+                continue;
+            }
+
+            ModuleDirectoryUtils.FindModulesFromDirectory(dir, externalModules);
+        }
+
+        externalModules.SetIgnoredDependencies(modules.LoadedModules.Select(m => m.ModuleInfo.Name));
+        await modules.LoadAsync(externalModules);
+    }
+
+    private static async Task SetupGbxRemoteConnection(ServicesBuilder s)
+    {
+        s.DependsOn(
+            "ActionInitializeEventManager",
+            "ActionInitializePlayerCache",
+            "ActionInitializeManialinkInteractionHandler",
+            "GbxRemoteClient"
+        );
+
+        var serverClient = s.GetInstance<IServerClient>();
+        s.GetInstance<IServerCallbackHandler>();
+        s.GetInstance<IRemoteChatRouter>();
+        await serverClient.StartAsync(CancellationToken.None);
+    }
+}
diff --git a/src/EvoSC.CLI/CliCommandContext.cs b/src/EvoSC.CLI/CliCommandContext.cs
deleted file mode 100644
index 3c1ca1bf1..000000000
--- a/src/EvoSC.CLI/CliCommandContext.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-using System.CommandLine.Invocation;
-
-namespace EvoSC.CLI;
-
-public class CliCommandContext
-{
-    public required InvocationContext InvocationContext { get; init;  }
-    public required string[] Args { get; init; }
-}
diff --git a/src/EvoSC.CLI/CliHandler.cs b/src/EvoSC.CLI/CliHandler.cs
deleted file mode 100644
index 50704edef..000000000
--- a/src/EvoSC.CLI/CliHandler.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-using System.CommandLine;
-using System.Reflection;
-using EvoSC.CLI.Attributes;
-using EvoSC.CLI.Exceptions;
-using EvoSC.CLI.Interfaces;
-
-namespace EvoSC.CLI;
-
-public class CliHandler
-{
-    private readonly RootCommand _rootCommand;
-    private readonly string[] _args;
-    
-    public CliHandler(string[] args)
-    {
-        _args = args;
-        _rootCommand = new RootCommand("EvoSC# TrackMania Server Controller.");
-    }
-
-    /// <summary>
-    /// Register a command to the command handler.
-    /// </summary>
-    /// <param name="cliCmd">An instance that implements the command.</param>
-    /// <returns></returns>
-    public CliHandler RegisterCommand(ICliCommand cliCmd)
-    {
-        var cmdAttr = GetCommandInfo(cliCmd);
-        var cmd = new Command(cmdAttr.Name, cmdAttr.Description);
-
-        var options = GetCommandOptions(cliCmd);
-        foreach (var option in options)
-        {
-            cmd.AddOption(option);
-        }
-        
-        cmd.SetHandler((invocationContext) =>
-        {
-            var context = new CliCommandContext {InvocationContext = invocationContext, Args = _args};
-            cliCmd.ExecuteAsync(CancellationToken.None, context).GetAwaiter().GetResult();
-        });
-        
-        _rootCommand.AddCommand(cmd);
-        return this;
-    }
-
-    /// <summary>
-    /// Check user input and run the appropriate commands if possible.
-    /// </summary>
-    /// <returns></returns>
-    public Task<int> HandleAsync()
-    {
-        return _rootCommand.InvokeAsync(_args);
-    }
-    
-    private IEnumerable<Option> GetCommandOptions(ICliCommand cliCmd)
-    {
-        var cmdOptions = cliCmd.GetType().GetCustomAttributes<CliOptionAttribute>();
-        var options = new List<Option>();
-
-        foreach (var cmdOption in cmdOptions)
-        {
-            var option = CreateOption(cmdOption);
-            options.Add(option);
-        }
-        
-        return options;
-    }
-    
-    private CliCommandAttribute GetCommandInfo(ICliCommand cliCmd)
-    {
-        var cmdAttr = cliCmd.GetType().GetCustomAttribute<CliCommandAttribute>();
-
-        if (cmdAttr == null)
-        {
-            throw new CliCommandAttributeNotFoundException();
-        }
-
-        return cmdAttr;
-    }
-
-    private Option CreateOption(CliOptionAttribute cmdOption)
-    {
-        var cmdOptionType = typeof(Option<>).MakeGenericType(new[] {cmdOption.TOption});
-        var option = (Option) Activator.CreateInstance(cmdOptionType, cmdOption.Aliases, cmdOption.Description);
-        
-        return option;
-    }
-}
diff --git a/src/EvoSC.CLI/CliManager.cs b/src/EvoSC.CLI/CliManager.cs
new file mode 100644
index 000000000..c8b3bd119
--- /dev/null
+++ b/src/EvoSC.CLI/CliManager.cs
@@ -0,0 +1,134 @@
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.ComponentModel;
+using System.Reflection;
+using EvoSC.CLI.Attributes;
+using EvoSC.CLI.Interfaces;
+using EvoSC.CLI.Models;
+using EvoSC.Common.Application;
+using EvoSC.Common.Config;
+using EvoSC.Common.Util;
+using EvoSC.Common.Util.EnumIdentifier;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EvoSC.CLI;
+
+public class CliManager : ICliManager
+{
+    private readonly RootCommand _rootCommand;
+    private readonly Option<CliEvoScConfig> _configOption;
+    private readonly List<ICliCommandInfo> _registeredCommands = new();
+
+    public CliManager()
+    {
+        _rootCommand = new RootCommand("EvoSC# TrackMania server controller.");
+
+        _configOption =
+            new Option<CliEvoScConfig>(new[] {"--option", "-o"},
+                description: "Override configuration options. Format is key:value");
+        
+        _rootCommand.AddGlobalOption(_configOption);
+    }
+    
+    public ICliManager RegisterCommands(Assembly assembly)
+    {
+        foreach (var cmdClass in assembly.AssemblyTypesWithAttribute<CliCommandAttribute>())
+        {
+            var handlerMethod = cmdClass.GetInstanceMethod("ExecuteAsync");
+            
+            var cmdAttr = cmdClass.GetCustomAttribute<CliCommandAttribute>();
+            var requiredFeatures = cmdClass.GetCustomAttribute<RequiredFeaturesAttribute>();
+
+            var command = new Command(cmdAttr!.Name, cmdAttr.Description);
+
+            var options = new List<Option>();
+            foreach (var param in handlerMethod.GetParameters())
+            {
+                var option = CreateOption(param);
+
+                if (option == null)
+                {
+                    throw new InvalidOperationException($"Failed to create option for CLI command {cmdClass.Name}");
+                }
+
+                options.Add(option);
+                command.AddOption(option);
+            }
+            
+            options.Add(_configOption);
+
+            var commandInfo = new CliCommandInfo
+            {
+                Command = command,
+                CommandClass = cmdClass,
+                HandlerMethod = handlerMethod,
+                Options = options.ToArray(),
+                RequiredFeatures = requiredFeatures?.Features ?? Array.Empty<AppFeature>()
+            };
+
+            command.SetHandler(async context =>
+            {
+                await ExecuteHandlerAsync(commandInfo, context);
+            });
+
+            _registeredCommands.Add(commandInfo);
+        }
+
+        return this;
+    }
+
+    private async Task ExecuteHandlerAsync(ICliCommandInfo command, InvocationContext context)
+    {
+        var paramValues = new List<object?>();
+
+        foreach (var option in command.Options)
+        {
+            var optionValue = context.BindingContext.ParseResult.GetValueForOption(option);
+            paramValues.Add(optionValue);
+        }
+
+        var cliConfig = context.BindingContext.ParseResult.GetValueForOption(_configOption);
+        var config = Configuration.GetBaseConfig(cliConfig?.Options ?? new Dictionary<string, object>());
+
+        var startupPipeline = new StartupPipeline(config);
+        startupPipeline.SetupBasePipeline(config);
+
+        await startupPipeline.ExecuteAsync(command.RequiredFeatures
+            .Select(feature => feature.ToString())
+            .ToArray()
+        );
+
+        var cmdObject = ActivatorUtilities.CreateInstance(startupPipeline.ServiceContainer, command.CommandClass);
+
+        var task = ReflectionUtils.CallMethod(cmdObject, "ExecuteAsync", paramValues) as Task;
+
+        if (task == null)
+        {
+            throw new InvalidOperationException("Failed to call CLI command handler as the task is null.");
+        }
+
+        await task;
+    }
+
+    private Option? CreateOption(ParameterInfo param)
+    {
+        var cmdOptionType = typeof(Option<>).MakeGenericType(new[] {param.ParameterType});
+        var aliases = cmdOptionType
+            .GetCustomAttributes<AliasAttribute>()
+            .Select(a => a.Name)
+            .ToList();
+
+        aliases.Add($"--{param.Name}");
+
+        var description = param.GetCustomAttribute<DescriptionAttribute>();
+
+        var option = Activator.CreateInstance(cmdOptionType, aliases, description?.Description ?? "") as Option;
+
+        return option;
+    }
+
+    public Task<int> ExecuteAsync(string[] args)
+    {
+        throw new NotImplementedException();
+    }
+}
diff --git a/src/EvoSC.CLI/EvoSC.CLI.csproj b/src/EvoSC.CLI/EvoSC.CLI.csproj
index d4e114540..d9b2eb685 100644
--- a/src/EvoSC.CLI/EvoSC.CLI.csproj
+++ b/src/EvoSC.CLI/EvoSC.CLI.csproj
@@ -11,7 +11,10 @@
     </ItemGroup>
 
     <ItemGroup>
+      <ProjectReference Include="..\EvoSC.Commands\EvoSC.Commands.csproj" />
       <ProjectReference Include="..\EvoSC.Common\EvoSC.Common.csproj" />
+      <ProjectReference Include="..\EvoSC.Manialinks\EvoSC.Manialinks.csproj" />
+      <ProjectReference Include="..\EvoSC.Modules\EvoSC.Modules.csproj" />
     </ItemGroup>
 
 </Project>
diff --git a/src/EvoSC.CLI/Exceptions/CliCommandAttributeNotFound.cs b/src/EvoSC.CLI/Exceptions/CliCommandAttributeNotFound.cs
deleted file mode 100644
index 1b35c2701..000000000
--- a/src/EvoSC.CLI/Exceptions/CliCommandAttributeNotFound.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-namespace EvoSC.CLI.Exceptions;
-
-/// <summary>
-/// Thrown when a command is not annotated with [CliCommand].
-/// </summary>
-public class CliCommandAttributeNotFoundException : EvoSCCliException
-{
-    
-}
diff --git a/src/EvoSC.CLI/Exceptions/EvoSCCliException.cs b/src/EvoSC.CLI/Exceptions/EvoSCCliException.cs
deleted file mode 100644
index f230d7620..000000000
--- a/src/EvoSC.CLI/Exceptions/EvoSCCliException.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using EvoSC.Common.Exceptions;
-
-namespace EvoSC.CLI.Exceptions;
-
-/// <summary>
-/// General exception for the CLI handler.
-/// </summary>
-public class EvoSCCliException : EvoSCException
-{
-    public EvoSCCliException(string? message) : base(message)
-    {
-    }
-
-    public EvoSCCliException(string? message, Exception? innerException) : base(message, innerException)
-    {
-    }
-
-    public EvoSCCliException()
-    {
-    }
-}
diff --git a/src/EvoSC.CLI/Interfaces/ICliCommand.cs b/src/EvoSC.CLI/Interfaces/ICliCommand.cs
deleted file mode 100644
index 439c9b525..000000000
--- a/src/EvoSC.CLI/Interfaces/ICliCommand.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-namespace EvoSC.CLI.Interfaces;
-
-public interface ICliCommand
-{
-    /// <summary>
-    /// Execute the command's handler.
-    /// </summary>
-    /// <param name="cancelToken">Cancel token to cancel the execution if set.</param>
-    /// <param name="context">The command's execution context.</param>
-    /// <returns></returns>
-    public Task ExecuteAsync(CancellationToken cancelToken, CliCommandContext context);
-}
diff --git a/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs b/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs
new file mode 100644
index 000000000..6337d034d
--- /dev/null
+++ b/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs
@@ -0,0 +1,15 @@
+using System.CommandLine;
+using System.Reflection;
+using EvoSC.CLI.Attributes;
+using EvoSC.Common.Application;
+
+namespace EvoSC.CLI.Interfaces;
+
+public interface ICliCommandInfo
+{
+    public Command Command { get; }
+    public Type CommandClass { get; }
+    public MethodInfo HandlerMethod { get; }
+    public Option[] Options { get; }
+    public AppFeature[] RequiredFeatures { get; }
+}
diff --git a/src/EvoSC.CLI/Interfaces/ICliManager.cs b/src/EvoSC.CLI/Interfaces/ICliManager.cs
new file mode 100644
index 000000000..4df0d73b2
--- /dev/null
+++ b/src/EvoSC.CLI/Interfaces/ICliManager.cs
@@ -0,0 +1,9 @@
+using System.Reflection;
+
+namespace EvoSC.CLI.Interfaces;
+
+public interface ICliManager
+{
+    public ICliManager RegisterCommands(Assembly assembly);
+    public Task<int> ExecuteAsync(string[] args);
+}
diff --git a/src/EvoSC.CLI/Models/CliCommandInfo.cs b/src/EvoSC.CLI/Models/CliCommandInfo.cs
new file mode 100644
index 000000000..3890c0a2f
--- /dev/null
+++ b/src/EvoSC.CLI/Models/CliCommandInfo.cs
@@ -0,0 +1,15 @@
+using System.CommandLine;
+using System.Reflection;
+using EvoSC.CLI.Interfaces;
+using EvoSC.Common.Application;
+
+namespace EvoSC.CLI.Models;
+
+public class CliCommandInfo : ICliCommandInfo
+{
+    public required Command Command { get; init; }
+    public required Type CommandClass { get; init; }
+    public required MethodInfo HandlerMethod { get; init; }
+    public Option[] Options { get; init; }
+    public AppFeature[] RequiredFeatures { get; init; }
+}
diff --git a/src/EvoSC.CLI/Models/CliEvoScConfig.cs b/src/EvoSC.CLI/Models/CliEvoScConfig.cs
new file mode 100644
index 000000000..32b7d1eec
--- /dev/null
+++ b/src/EvoSC.CLI/Models/CliEvoScConfig.cs
@@ -0,0 +1,8 @@
+using System.CommandLine.Binding;
+
+namespace EvoSC.CLI.Models;
+
+public class CliEvoScConfig
+{
+    public Dictionary<string, object> Options { get; set; }
+}
diff --git a/src/EvoSC.CLI/Models/CliEvoScConfigBinder.cs b/src/EvoSC.CLI/Models/CliEvoScConfigBinder.cs
new file mode 100644
index 000000000..3da489df8
--- /dev/null
+++ b/src/EvoSC.CLI/Models/CliEvoScConfigBinder.cs
@@ -0,0 +1,15 @@
+using System.CommandLine.Binding;
+
+namespace EvoSC.CLI.Models;
+
+public class CliEvoScConfigBinder : BinderBase<CliEvoScConfig>
+{
+    
+    
+    protected override CliEvoScConfig GetBoundValue(BindingContext bindingContext)
+    {
+        return new CliEvoScConfig {Options = new Dictionary<string, object>()};
+    }
+    
+    
+}
diff --git a/src/EvoSC.Common/Application/AppFeature.cs b/src/EvoSC.Common/Application/AppFeature.cs
new file mode 100644
index 000000000..c3562974a
--- /dev/null
+++ b/src/EvoSC.Common/Application/AppFeature.cs
@@ -0,0 +1,24 @@
+namespace EvoSC.Common.Application;
+
+public enum AppFeature
+{
+    All,
+    Config,
+    Logging,
+    DatabaseMigrations,
+    Database,
+    Events,
+    GbxRemoteClient,
+    Modules,
+    ControllerManager,
+    PlayerManager,
+    MapsManager,
+    PlayerCache,
+    MatchSettings,
+    Auditing,
+    ServicesManager,
+    ChatCommands,
+    ActionPipelines,
+    Permissions,
+    Manialinks
+}
diff --git a/src/EvoSC.Common/Application/ServicesBuilder.cs b/src/EvoSC.Common/Application/ServicesBuilder.cs
new file mode 100644
index 000000000..37618d4e2
--- /dev/null
+++ b/src/EvoSC.Common/Application/ServicesBuilder.cs
@@ -0,0 +1,11 @@
+using SimpleInjector;
+
+namespace EvoSC.Common.Application;
+
+public class ServicesBuilder : Container
+{
+    public ServicesBuilder DependsOn(params string[] dependencies)
+    {
+        return this;
+    }
+}
diff --git a/src/EvoSC.Common/Application/StartupPipeline.cs b/src/EvoSC.Common/Application/StartupPipeline.cs
new file mode 100644
index 000000000..374bf4581
--- /dev/null
+++ b/src/EvoSC.Common/Application/StartupPipeline.cs
@@ -0,0 +1,44 @@
+using EvoSC.Common.Config.Models;
+using EvoSC.Common.Interfaces;
+using SimpleInjector;
+
+namespace EvoSC.Common.Application;
+
+public class StartupPipeline : IStartupPipeline
+{
+    private readonly IEvoScBaseConfig _config;
+    private readonly ServicesBuilder _services;
+
+    public StartupPipeline(IEvoScBaseConfig config)
+    {
+        _config = config;
+        _services = new ServicesBuilder();
+    }
+
+    public Container ServiceContainer => _services;
+
+    public IStartupPipeline Services(string name, Action<ServicesBuilder> servicesConfig)
+    {
+        throw new NotImplementedException();
+    }
+
+    public IStartupPipeline Action(string name, Action<ServicesBuilder> action)
+    {
+        throw new NotImplementedException();
+    }
+
+    public IStartupPipeline ActionAsync(string name, Func<ServicesBuilder, Task> action)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task ExecuteAsync(params string[] components)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task ExecuteAllAsync()
+    {
+        throw new NotImplementedException();
+    }
+}
diff --git a/src/EvoSC.Common/Config/ConfigServiceExtensions.cs b/src/EvoSC.Common/Config/ConfigServiceExtensions.cs
deleted file mode 100644
index f2eb81730..000000000
--- a/src/EvoSC.Common/Config/ConfigServiceExtensions.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-using Config.Net;
-using EvoSC.Common.Config.Models;
-using EvoSC.Common.Config.Stores;
-using EvoSC.Common.Config.Mapping;
-using EvoSC.Common.Config.Mapping.Toml;
-using EvoSC.Common.Interfaces.Config.Mapping;
-using SimpleInjector;
-
-namespace EvoSC.Common.Config;
-
-public static class ConfigServiceExtensions
-{
-    private const string MainConfigFile = "config/main.toml";
-    
-    /// <summary>
-    /// Set up and parse EvoSC's base configuration. This method also adds the configuration
-    /// to the service container.
-    /// </summary>
-    /// <param name="services"></param>
-    /// <returns></returns>
-    public static IEvoScBaseConfig AddEvoScConfig(this Container services)
-    {
-        SetupTomlMapping(services);
-
-        var baseConfig = new ConfigurationBuilder<IEvoScBaseConfig>()
-            .UseTomlFile(MainConfigFile)
-            .UseTypeParser(new TextColorTypeParser())
-            .Build();
-
-        services.RegisterInstance<IEvoScBaseConfig>(baseConfig);
-        
-        return baseConfig;
-    }
-
-    private static void SetupTomlMapping(Container services)
-    {
-        var mappingManager = new TomlMappingManager();
-        mappingManager.SetupDefaultMappers();
-        services.RegisterInstance<ITomlMappingManager>(mappingManager);
-    }
-}
diff --git a/src/EvoSC.Common/Config/Configuration.cs b/src/EvoSC.Common/Config/Configuration.cs
new file mode 100644
index 000000000..4a6c62d24
--- /dev/null
+++ b/src/EvoSC.Common/Config/Configuration.cs
@@ -0,0 +1,37 @@
+using Config.Net;
+using EvoSC.Common.Config.Models;
+using EvoSC.Common.Config.Stores;
+using EvoSC.Common.Config.Mapping;
+using EvoSC.Common.Config.Mapping.Toml;
+using EvoSC.Common.Interfaces.Config.Mapping;
+using SimpleInjector;
+
+namespace EvoSC.Common.Config;
+
+public static class Configuration
+{
+    private const string MainConfigFile = "config/main.toml";
+    
+    /// <summary>
+    /// Set up and parse EvoSC's base configuration.
+    /// </summary>
+    /// <param name="configFile">The TOML file containing the base config.</param>
+    /// <returns></returns>
+    public static IEvoScBaseConfig GetBaseConfig(string configFile, Dictionary<string, object> cliOptions)
+    {
+        ConfigMapper.SetupDefaultMappers();
+
+        var baseConfig = new ConfigurationBuilder<IEvoScBaseConfig>()
+            .UseEvoScConfig(MainConfigFile, cliOptions)
+            .UseTypeParser(new TextColorTypeParser())
+            .Build();
+        
+        return baseConfig;
+    }
+
+    /// <summary>
+    /// Set up and parse EvoSC's base configuration.
+    /// </summary>
+    /// <returns></returns>
+    public static IEvoScBaseConfig GetBaseConfig(Dictionary<string, object> cliOptions) => GetBaseConfig(MainConfigFile, cliOptions);
+}
diff --git a/src/EvoSC.Common/Config/Mapping/Toml/TomlMappingManaager.cs b/src/EvoSC.Common/Config/Mapping/Toml/ConfigMapper.cs
similarity index 61%
rename from src/EvoSC.Common/Config/Mapping/Toml/TomlMappingManaager.cs
rename to src/EvoSC.Common/Config/Mapping/Toml/ConfigMapper.cs
index d0795e120..cf880d341 100644
--- a/src/EvoSC.Common/Config/Mapping/Toml/TomlMappingManaager.cs
+++ b/src/EvoSC.Common/Config/Mapping/Toml/ConfigMapper.cs
@@ -3,12 +3,12 @@
 
 namespace EvoSC.Common.Config.Mapping.Toml;
 
-public class TomlMappingManager : ITomlMappingManager
+public class ConfigMapper
 {
-    public void AddMapper<T>(ITomlTypeMapper<T> mapper) =>
+    public static void AddMapper<T>(ITomlTypeMapper<T> mapper) =>
         TomletMain.RegisterMapper(mapper.Serialize, mapper.Deserialize);
 
-    public void SetupDefaultMappers()
+    public static void SetupDefaultMappers()
     {
         AddMapper(new TextColorTomlMapper());
     }
diff --git a/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs b/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
new file mode 100644
index 000000000..222e7f969
--- /dev/null
+++ b/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
@@ -0,0 +1,47 @@
+using Config.Net;
+using EvoSC.Common.Config.Models;
+
+namespace EvoSC.Common.Config.Stores;
+
+public class EvoScBaseConfigStore : IConfigStore
+{
+    private readonly TomlConfigStore<IEvoScBaseConfig> _tomlConfigStore;
+    private readonly Dictionary<string, object> _cliOptions;
+    
+    public EvoScBaseConfigStore(string path, Dictionary<string, object> cliOptions)
+    {
+        _cliOptions = cliOptions;
+        _tomlConfigStore = new TomlConfigStore<IEvoScBaseConfig>(path);
+    }
+
+    public void Dispose()
+    {
+        _tomlConfigStore.Dispose();
+    }
+
+    public string? Read(string key)
+    {
+        var configValue = _tomlConfigStore.Read(key);
+
+        if (configValue == null)
+        {
+            return null;
+        }
+        
+        var enviName = $"EVOSC_{key.Replace(".", "_").ToUpper()}";
+        var enviValue = Environment.GetEnvironmentVariable(enviName);
+
+        _cliOptions.TryGetValue(key, out var cliValue);
+
+        // try cli options, then environment variables and then config file
+        return cliValue?.ToString() ?? enviValue ?? configValue;
+    }
+
+    public void Write(string key, string? value)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool CanRead => true;
+    public bool CanWrite => false;
+}
diff --git a/src/EvoSC.Common/Config/Stores/StoreExtensions.cs b/src/EvoSC.Common/Config/Stores/StoreExtensions.cs
index 599758ffb..b28568b3f 100644
--- a/src/EvoSC.Common/Config/Stores/StoreExtensions.cs
+++ b/src/EvoSC.Common/Config/Stores/StoreExtensions.cs
@@ -11,10 +11,10 @@ public static class StoreExtensions
     /// <param name="path">The path to the config file.</param>
     /// <typeparam name="TInterface">The interface which defines the config options.</typeparam>
     /// <returns></returns>
-    public static ConfigurationBuilder<TInterface> UseTomlFile<TInterface>(
-        this ConfigurationBuilder<TInterface> builder, string path) where TInterface : class
+    public static ConfigurationBuilder<TInterface> UseEvoScConfig<TInterface>(
+        this ConfigurationBuilder<TInterface> builder, string path, Dictionary<string, object> cliOptions) where TInterface : class
     {
-        builder.UseConfigStore(new TomlConfigStore<TInterface>(path));
+        builder.UseConfigStore(new EvoScBaseConfigStore(path, cliOptions));
         return builder;
     }
 }
diff --git a/src/EvoSC.Common/Config/Stores/TomlConfigStore.cs b/src/EvoSC.Common/Config/Stores/TomlConfigStore.cs
index 31d91c7ec..c34070ea9 100644
--- a/src/EvoSC.Common/Config/Stores/TomlConfigStore.cs
+++ b/src/EvoSC.Common/Config/Stores/TomlConfigStore.cs
@@ -99,6 +99,7 @@ private string GetArrayValue(string key)
 
         return string.Join(" ", value.Select(v => v.StringValue));
     }
+    
     public string? Read(string key)
     {
         var lastDotIndex = key.LastIndexOf(".", StringComparison.Ordinal);
diff --git a/src/EvoSC.Common/Database/Extensions/DatabaseServiceExtensions.cs b/src/EvoSC.Common/Database/Extensions/DatabaseServiceExtensions.cs
index 176635746..6caa02278 100644
--- a/src/EvoSC.Common/Database/Extensions/DatabaseServiceExtensions.cs
+++ b/src/EvoSC.Common/Database/Extensions/DatabaseServiceExtensions.cs
@@ -1,4 +1,5 @@
-using EvoSC.Common.Config.Models;
+using EvoSC.Common.Application;
+using EvoSC.Common.Config.Models;
 using EvoSC.Common.Database.Repository.Audit;
 using EvoSC.Common.Database.Repository.Maps;
 using EvoSC.Common.Database.Repository.Permissions;
@@ -13,7 +14,7 @@ namespace EvoSC.Common.Database.Extensions;
 
 public static class DatabaseServiceExtensions
 {
-    public static Container AddEvoScDatabase(this Container services, IDatabaseConfig config)
+    public static ServicesBuilder AddEvoScDatabase(this ServicesBuilder services, IDatabaseConfig config)
     {
         services.Register<IDbConnectionFactory, DbConnectionFactory>();
         
@@ -26,7 +27,7 @@ public static Container AddEvoScDatabase(this Container services, IDatabaseConfi
         return services;
     }
 
-    public static Container AddEvoScMigrations(this Container services)
+    public static ServicesBuilder AddEvoScMigrations(this ServicesBuilder services)
     {
         services.Register<IMigrationManager, MigrationManager>(Lifestyle.Scoped);
         return services;
diff --git a/src/EvoSC.Common/Interfaces/IEvoSCApplication.cs b/src/EvoSC.Common/Interfaces/IEvoSCApplication.cs
index d2254ee7d..9cfe1b711 100644
--- a/src/EvoSC.Common/Interfaces/IEvoSCApplication.cs
+++ b/src/EvoSC.Common/Interfaces/IEvoSCApplication.cs
@@ -4,6 +4,8 @@ namespace EvoSC.Common.Interfaces;
 
 public interface IEvoSCApplication
 {
+    public IStartupPipeline StartupPipeline { get; }
+    
     /// <summary>
     /// Global cancellation token of the application. This is set when ShutdownAsync is called.
     /// </summary>
diff --git a/src/EvoSC.Common/Interfaces/IStartupPipeline.cs b/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
new file mode 100644
index 000000000..7297a3a19
--- /dev/null
+++ b/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
@@ -0,0 +1,25 @@
+using EvoSC.Common.Application;
+using EvoSC.Common.Util;
+using EvoSC.Common.Util.EnumIdentifier;
+using SimpleInjector;
+
+namespace EvoSC.Common.Interfaces;
+
+public interface IStartupPipeline
+{
+    public Container ServiceContainer { get; }
+    
+    public IStartupPipeline Services(string name, Action<ServicesBuilder> servicesConfig);
+
+    public IStartupPipeline Services(Enum name, Action<ServicesBuilder> servicesConfig) =>
+        Services(name.GetIdentifier(), servicesConfig);
+    public IStartupPipeline Action(string name, Action<ServicesBuilder> action);
+    public IStartupPipeline Action(Enum name, Action<ServicesBuilder> action) => Action(name.GetIdentifier(), action);
+    public IStartupPipeline ActionAsync(string name, Func<ServicesBuilder, Task> action);
+
+    public IStartupPipeline ActionAsync(Enum name, Func<ServicesBuilder, Task> action) =>
+        ActionAsync(name.GetIdentifier(), action);
+
+    public Task ExecuteAsync(params string[] components);
+    public Task ExecuteAllAsync();
+}
diff --git a/src/EvoSC/Application.cs b/src/EvoSC/Application.cs
index ca9d8ecfe..91ea1d48f 100644
--- a/src/EvoSC/Application.cs
+++ b/src/EvoSC/Application.cs
@@ -1,6 +1,8 @@
 using System.Diagnostics;
+using EvoSC.CLI;
 using EvoSC.Commands;
 using EvoSC.Commands.Interfaces;
+using EvoSC.Common.Application;
 using EvoSC.Common.Config;
 using EvoSC.Common.Config.Models;
 using EvoSC.Common.Controllers;
@@ -30,43 +32,60 @@ namespace EvoSC;
 
 public sealed class Application : IEvoSCApplication, IDisposable
 {
-    private readonly string[] _args;
-    private Container _services;
     private readonly bool _isDebug;
     private ILogger<Application> _logger;
 
+    private readonly IEvoScBaseConfig _config;
+
     private readonly CancellationTokenSource _runningToken = new();
 
+    public IStartupPipeline StartupPipeline { get; }
+
     public CancellationToken MainCancellationToken => _runningToken.Token;
-    public Container Services => _services;
+    public Container Services => StartupPipeline.ServiceContainer;
 
-    public Application(string[] args)
+    public Application(IEvoScBaseConfig config)
     {
-        _args = args;
+        _config = config;
         _isDebug = Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") == "Development";
+        StartupPipeline = new StartupPipeline(_config);
+
+        StartupPipeline.Services("Application", s => s.RegisterInstance<IEvoSCApplication>(this));
+        StartupPipeline.Services("Config", s => s.RegisterInstance(_config));
 
         ConfigureServiceContainer();
     }
 
     private void ConfigureServiceContainer()
     {
-        _services = new Container();
-        _services.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
-        _services.Options.EnableAutoVerification = false;
-        _services.Options.ResolveUnregisteredConcreteTypes = true;
-        _services.Options.SuppressLifestyleMismatchVerification = true;
-        _services.Options.UseStrictLifestyleMismatchBehavior = false;
+        StartupPipeline.ServiceContainer.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
+        StartupPipeline.ServiceContainer.Options.EnableAutoVerification = false;
+        StartupPipeline.ServiceContainer.Options.ResolveUnregisteredConcreteTypes = true;
+        StartupPipeline.ServiceContainer.Options.SuppressLifestyleMismatchVerification = true;
+        StartupPipeline.ServiceContainer.Options.UseStrictLifestyleMismatchBehavior = false;
     }
 
     public async Task RunAsync()
     {
-        await SetupApplicationAsync();
+        // await SetupApplicationAsync();
+        
+        StartupPipeline.SetupBasePipeline(_config);
+        await StartupPipeline.ExecuteAllAsync();
 
         // wait indefinitely
         WaitHandle.WaitAll(new[] {_runningToken.Token.WaitHandle});
     }
-
+    
     public async Task ShutdownAsync()
+    {
+        var serverClient = Services.GetInstance<IServerClient>();
+        await serverClient.StopAsync(_runningToken.Token);
+        
+        // cancel the token to stop the application itself
+        _runningToken.Cancel();
+    }
+
+    /* public async Task ShutdownAsync()
     {
         var serverClient = _services.GetInstance<IServerClient>();
         await serverClient.StopAsync(_runningToken.Token);
@@ -79,7 +98,7 @@ private async Task SetupApplicationAsync()
     {
         var sw = new Stopwatch();
         sw.Start();
-        
+
         SetupServices();
         MigrateDatabase();
         SetupControllerManager();
@@ -95,12 +114,10 @@ private async Task SetupApplicationAsync()
 
     private void SetupServices()
     {
-        var config = _services.AddEvoScConfig();
-
-        _services.AddEvoScLogging(config.Logging);
+        _services.AddEvoScLogging(_config.Logging);
         
         _services.AddEvoScMigrations();
-        _services.AddEvoScDatabase(config.Database);
+        _services.AddEvoScDatabase(_config.Database);
         
         _services.AddGbxRemoteClient();
         _services.AddEvoScEvents();
@@ -194,18 +211,18 @@ private async Task InitializeTemplatesAsync()
     {
         var maniaLinks = _services.GetRequiredService<IManialinkManager>();
         await maniaLinks.PreprocessAllAsync();
-    }
+    } */
 
     public void Dispose()
     {
-        var moduleManager = _services.GetInstance<IModuleManager>();
+        var moduleManager = Services.GetInstance<IModuleManager>();
 
         foreach (var module in moduleManager.LoadedModules)
         {
             moduleManager.UnloadAsync(module.LoadId).GetAwaiter().GetResult();
         }
         
-        _services.Dispose();
+        Services.Dispose();
         _runningToken.Dispose();
     }
 }
diff --git a/src/EvoSC/CliCommands/RunCommand.cs b/src/EvoSC/CliCommands/RunCommand.cs
index d5f843d69..66ed3b32d 100644
--- a/src/EvoSC/CliCommands/RunCommand.cs
+++ b/src/EvoSC/CliCommands/RunCommand.cs
@@ -1,16 +1,26 @@
 using EvoSC.CLI;
 using EvoSC.CLI.Attributes;
-using EvoSC.CLI.Interfaces;
+using EvoSC.CLI.Models;
+using EvoSC.Common.Application;
+using EvoSC.Common.Config;
+using EvoSC.Common.Config.Models;
 
 namespace EvoSC.CliCommands;
 
 [CliCommand(Name = "run", Description = "Start the server controller.")]
-[CliOption(typeof(int), "Verbosity level of the output.", "--verbosity", "-v")]
-public class RunCommand : ICliCommand
+[RequiredFeatures(AppFeature.Config)]
+public class RunCommand
 {
-    public async Task ExecuteAsync(CancellationToken cancelToken, CliCommandContext context)
+    private readonly IEvoScBaseConfig _config;
+    
+    public RunCommand(IEvoScBaseConfig config)
     {
-        var app = new Application(context.Args);
+        _config = config;
+    }
+    
+    public async Task ExecuteAsync()
+    {
+        var app = new Application(_config);
         await app.RunAsync();
         app.Dispose();
     }
diff --git a/src/EvoSC/EvoSC.csproj b/src/EvoSC/EvoSC.csproj
index 7efaee0d7..a6aa084ab 100644
--- a/src/EvoSC/EvoSC.csproj
+++ b/src/EvoSC/EvoSC.csproj
@@ -33,5 +33,9 @@
     <ItemGroup>
         <Content Include="bin\Debug\net7.0\config\main.toml" />
     </ItemGroup>
+
+    <ItemGroup>
+      <Folder Include="Interfaces\" />
+    </ItemGroup>
     
 </Project>
diff --git a/src/EvoSC/Program.cs b/src/EvoSC/Program.cs
index bf112681d..691bc3c09 100644
--- a/src/EvoSC/Program.cs
+++ b/src/EvoSC/Program.cs
@@ -1,7 +1,7 @@
 
+using EvoSC;
 using EvoSC.CLI;
-using EvoSC.CliCommands;
 
-return await new CliHandler(args)
-    .RegisterCommand(new RunCommand())
-    .HandleAsync();
+return await new CliManager()
+    .RegisterCommands(typeof(Application).Assembly)
+    .ExecuteAsync(args);
diff --git a/tests/EvoSC.CLI.Tests/CliHandlerTests.cs b/tests/EvoSC.CLI.Tests/CliHandlerTests.cs
index 2cb105dbe..66d36ef82 100644
--- a/tests/EvoSC.CLI.Tests/CliHandlerTests.cs
+++ b/tests/EvoSC.CLI.Tests/CliHandlerTests.cs
@@ -10,45 +10,5 @@ namespace EvoSC.CLI.Tests;
 
 public class CliHandlerTests
 {
-    class InvalidCmdClass : ICliCommand
-    {
-        public Task ExecuteAsync(CancellationToken cancelToken, CliCommandContext context)
-        {
-            throw new System.NotImplementedException();
-        }
-    }
-
-    class MyCommandRanException : Exception {}
-    
-    [CliCommand(Name="mycmd", Description="My command.")]
-    class MyCmd : ICliCommand
-    {
-        public Task ExecuteAsync(CancellationToken cancelToken, CliCommandContext context)
-        {
-            throw new MyCommandRanException();
-        }
-    }
     
-    [Fact]
-    public void Registration_Throws_Exception_If_Attribute_Is_Not_Defined()
-    {
-        var handler = new CliHandler(Array.Empty<string>());
-
-        Assert.Throws<CliCommandAttributeNotFoundException>(() =>
-        {
-            handler.RegisterCommand(new InvalidCmdClass());
-        });
-    }
-
-    [Fact]
-    public void Handler_Runs_Registered_Command()
-    {
-        var handler = new CliHandler(new[] {"mycmd"});
-        handler.RegisterCommand(new MyCmd());
-
-        Assert.ThrowsAsync<MyCommandRanException>(async () =>
-        {
-            await handler.HandleAsync();
-        });
-    }
 }
diff --git a/tests/EvoSC.Common.Tests/TestFiles/ConfigTests.cs b/tests/EvoSC.Common.Tests/TestFiles/ConfigTests.cs
index a92d0f9bd..9db1bbfa2 100644
--- a/tests/EvoSC.Common.Tests/TestFiles/ConfigTests.cs
+++ b/tests/EvoSC.Common.Tests/TestFiles/ConfigTests.cs
@@ -7,17 +7,4 @@ namespace EvoSC.Common.Tests.TestFiles;
 
 public class ConfigTests
 {
-    [Fact]
-    public void Test_Server_Config_Is_Properly_Parsed()
-    {
-        var config = new ConfigurationBuilder<IEvoScBaseConfig>()
-            .UseTomlFile("TestFiles/Config/BasicConfig/main.toml")
-            .Build();
-        
-        Assert.Equal("123.123.123.123", config.Server.Host);
-        Assert.Equal(1234, config.Server.Port);
-        Assert.Equal("My Admin ", config.Server.Username);
-        Assert.Equal(" My Admin", config.Server.Password);
-        Assert.False(config.Server.RetryConnection);
-    }
 }

From 1ff572e7efdffb9a912e770f520ddbdb578c2378 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Fri, 30 Jun 2023 10:39:08 +0200
Subject: [PATCH 02/22] Add execution of startup pipeline.

---
 src/EvoSC.CLI/CliManager.cs                   |  44 +++++-
 src/EvoSC.CLI/CliStartup.cs                   | 128 ++++++++++++++++++
 src/EvoSC.Common/Application/AppFeature.cs    |  40 +++++-
 .../Models/ActionStartupComponent.cs          |  10 ++
 .../Models/AsyncActionStartupComponent.cs     |  10 ++
 .../Models/ServiceStartupComponent.cs         |  10 ++
 .../Application/ServicesBuilder.cs            |   4 -
 .../Application/StartupPipeline.cs            |  95 +++++++++++--
 src/EvoSC.Common/Config/Configuration.cs      |   4 +-
 .../Config/Stores/EvoSCBaseConfigStore.cs     |   4 +-
 .../Config/Stores/StoreExtensions.cs          |   2 +-
 .../Application/IActionStartupComponent.cs    |   8 ++
 .../IAsyncActionStartupComponent.cs           |   8 ++
 .../Application/IServiceStartupComponent.cs   |   8 ++
 .../Application/IStartupComponent.cs          |   7 +
 .../Interfaces/IStartupPipeline.cs            |  19 +--
 .../Logging/LoggingServiceExtensions.cs       |   3 +-
 src/EvoSC.Common/Util/ReflectionUtils.cs      |   2 +-
 src/EvoSC/Application.cs                      |   2 +-
 .../ApplicationSetup.cs}                      |  41 ++----
 src/EvoSC/CliCommands/RunCommand.cs           |   4 +-
 21 files changed, 383 insertions(+), 70 deletions(-)
 create mode 100644 src/EvoSC.CLI/CliStartup.cs
 create mode 100644 src/EvoSC.Common/Application/Models/ActionStartupComponent.cs
 create mode 100644 src/EvoSC.Common/Application/Models/AsyncActionStartupComponent.cs
 create mode 100644 src/EvoSC.Common/Application/Models/ServiceStartupComponent.cs
 create mode 100644 src/EvoSC.Common/Interfaces/Application/IActionStartupComponent.cs
 create mode 100644 src/EvoSC.Common/Interfaces/Application/IAsyncActionStartupComponent.cs
 create mode 100644 src/EvoSC.Common/Interfaces/Application/IServiceStartupComponent.cs
 create mode 100644 src/EvoSC.Common/Interfaces/Application/IStartupComponent.cs
 rename src/{EvoSC.CLI/BaseStartup.cs => EvoSC/ApplicationSetup.cs} (85%)

diff --git a/src/EvoSC.CLI/CliManager.cs b/src/EvoSC.CLI/CliManager.cs
index c8b3bd119..a42900aa5 100644
--- a/src/EvoSC.CLI/CliManager.cs
+++ b/src/EvoSC.CLI/CliManager.cs
@@ -9,6 +9,7 @@
 using EvoSC.Common.Config;
 using EvoSC.Common.Util;
 using EvoSC.Common.Util.EnumIdentifier;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace EvoSC.CLI;
@@ -16,7 +17,7 @@ namespace EvoSC.CLI;
 public class CliManager : ICliManager
 {
     private readonly RootCommand _rootCommand;
-    private readonly Option<CliEvoScConfig> _configOption;
+    private readonly Option<IEnumerable<string>> _configOption;
     private readonly List<ICliCommandInfo> _registeredCommands = new();
 
     public CliManager()
@@ -24,7 +25,7 @@ public CliManager()
         _rootCommand = new RootCommand("EvoSC# TrackMania server controller.");
 
         _configOption =
-            new Option<CliEvoScConfig>(new[] {"--option", "-o"},
+            new Option<IEnumerable<string>>(new[] {"--option", "-o"},
                 description: "Override configuration options. Format is key:value");
         
         _rootCommand.AddGlobalOption(_configOption);
@@ -34,7 +35,13 @@ public ICliManager RegisterCommands(Assembly assembly)
     {
         foreach (var cmdClass in assembly.AssemblyTypesWithAttribute<CliCommandAttribute>())
         {
-            var handlerMethod = cmdClass.GetInstanceMethod("ExecuteAsync");
+            var handlerMethod = cmdClass.GetMethod("ExecuteAsync");
+
+            if (handlerMethod == null)
+            {
+                throw new InvalidOperationException(
+                    $"Did not find the ExecuteAsync method in CLI command: {cmdClass.Name}");
+            }
             
             var cmdAttr = cmdClass.GetCustomAttribute<CliCommandAttribute>();
             var requiredFeatures = cmdClass.GetCustomAttribute<RequiredFeaturesAttribute>();
@@ -72,6 +79,7 @@ public ICliManager RegisterCommands(Assembly assembly)
             });
 
             _registeredCommands.Add(commandInfo);
+            _rootCommand.AddCommand(command);
         }
 
         return this;
@@ -83,12 +91,35 @@ private async Task ExecuteHandlerAsync(ICliCommandInfo command, InvocationContex
 
         foreach (var option in command.Options)
         {
+            if (option == _configOption)
+            {
+                continue;
+            }
+            
             var optionValue = context.BindingContext.ParseResult.GetValueForOption(option);
             paramValues.Add(optionValue);
         }
 
         var cliConfig = context.BindingContext.ParseResult.GetValueForOption(_configOption);
-        var config = Configuration.GetBaseConfig(cliConfig?.Options ?? new Dictionary<string, object>());
+        var cliConfigOptions = new Dictionary<string, string> ();
+
+        if (cliConfig != null)
+        {
+            foreach (var cliConfigOption in cliConfig)
+            {
+                var kv = cliConfigOption.Split(':', 2);
+
+                if (kv.Length < 2)
+                {
+                    throw new InvalidOperationException(
+                        $"The provided config option {cliConfigOption} is in an invalid format.");
+                }
+
+                cliConfigOptions[kv[0]] = kv[1];
+            }
+        }
+
+        var config = Configuration.GetBaseConfig(cliConfigOptions);
 
         var startupPipeline = new StartupPipeline(config);
         startupPipeline.SetupBasePipeline(config);
@@ -100,7 +131,8 @@ await startupPipeline.ExecuteAsync(command.RequiredFeatures
 
         var cmdObject = ActivatorUtilities.CreateInstance(startupPipeline.ServiceContainer, command.CommandClass);
 
-        var task = ReflectionUtils.CallMethod(cmdObject, "ExecuteAsync", paramValues) as Task;
+        var methodArgs = paramValues?.ToArray() ?? Array.Empty<object>();
+        var task = ReflectionUtils.CallMethod(cmdObject, "ExecuteAsync", methodArgs) as Task;
 
         if (task == null)
         {
@@ -129,6 +161,6 @@ await startupPipeline.ExecuteAsync(command.RequiredFeatures
 
     public Task<int> ExecuteAsync(string[] args)
     {
-        throw new NotImplementedException();
+        return _rootCommand.InvokeAsync(args);
     }
 }
diff --git a/src/EvoSC.CLI/CliStartup.cs b/src/EvoSC.CLI/CliStartup.cs
new file mode 100644
index 000000000..b8aa3a508
--- /dev/null
+++ b/src/EvoSC.CLI/CliStartup.cs
@@ -0,0 +1,128 @@
+using System.Reflection.PortableExecutable;
+using EvoSC.Commands;
+using EvoSC.Commands.Interfaces;
+using EvoSC.Common.Application;
+using EvoSC.Common.Config.Models;
+using EvoSC.Common.Controllers;
+using EvoSC.Common.Database;
+using EvoSC.Common.Database.Extensions;
+using EvoSC.Common.Events;
+using EvoSC.Common.Interfaces;
+using EvoSC.Common.Interfaces.Controllers;
+using EvoSC.Common.Interfaces.Middleware;
+using EvoSC.Common.Interfaces.Services;
+using EvoSC.Common.Logging;
+using EvoSC.Common.Middleware;
+using EvoSC.Common.Permissions;
+using EvoSC.Common.Remote;
+using EvoSC.Common.Services;
+using EvoSC.Manialinks;
+using EvoSC.Manialinks.Interfaces;
+using EvoSC.Modules.Extensions;
+using EvoSC.Modules.Interfaces;
+using EvoSC.Modules.Util;
+using SimpleInjector;
+
+namespace EvoSC.CLI;
+
+public static class CliStartup
+{
+    public static void SetupBasePipeline(this IStartupPipeline pipeline, IEvoScBaseConfig config)
+    {
+        pipeline
+            .Services(AppFeature.Config, s => s.RegisterInstance(config))
+
+            .Services(AppFeature.Logging, s => s.AddEvoScLogging(config.Logging))
+
+            .Services(AppFeature.DatabaseMigrations, s => s.AddEvoScMigrations())
+
+            .Services(AppFeature.Database, s => s
+                    .AddEvoScDatabase(config.Database)
+                , "DatabaseMigrations")
+
+            .Services(AppFeature.Events, s => s.AddEvoScEvents())
+
+            .Services(AppFeature.GbxRemoteClient, s => s.AddGbxRemoteClient())
+
+            .Services(AppFeature.Modules, s => s.AddEvoScModules())
+
+            .Services(AppFeature.ControllerManager, s => s.AddEvoScControllers())
+
+            .Services(AppFeature.PlayerManager, s => s
+                .Register<IPlayerManagerService, PlayerManagerService>(Lifestyle.Transient)
+            )
+
+            .Services(AppFeature.MapsManager, s => s
+                .Register<IMapService, MapService>(Lifestyle.Transient)
+            )
+
+            .Services(AppFeature.PlayerCache, s => s
+                .RegisterSingleton<IPlayerCacheService, PlayerCacheService>()
+            )
+
+            .Services(AppFeature.MatchSettings, s => s
+                .Register<IMatchSettingsService, MatchSettingsService>(Lifestyle.Transient)
+            )
+
+            .Services(AppFeature.Auditing, s => s
+                .Register<IAuditService, AuditService>(Lifestyle.Transient)
+            )
+
+            .Services(AppFeature.ServicesManager, s => s
+                .RegisterSingleton<IServiceContainerManager, ServiceContainerManager>()
+            )
+
+            .Services(AppFeature.ChatCommands, s => s.AddEvoScChatCommands())
+
+            .Services(AppFeature.ActionPipelines, s => s.AddEvoScMiddlewarePipelines())
+
+            .Services(AppFeature.Permissions, s => s.AddEvoScPermissions())
+
+            .Services(AppFeature.Manialinks, s => s.AddEvoScManialinks())
+
+            .Action("ActionMigrateDatabase", MigrateDatabase, "DatabaseMigrations")
+
+            .Action("ActionInitializeEventManager", s => s
+                    .GetInstance<IEventManager>()
+                , "Events")
+
+            .Action("ActionInitializePlayerCache", s => s
+                    .GetInstance<IPlayerCacheService>()
+                , "PlayerCache")
+
+            .Action("ActionInitializeManialinkInteractionHandler", s => s
+                    .GetInstance<IManialinkInteractionHandler>()
+                , "ActionInitializeEventManager", "ActionInitializePlayerCache")
+
+            .ActionAsync("InitializeGbxRemoteConnection", SetupGbxRemoteConnection,
+                "ActionInitializeEventManager",
+                "ActionInitializePlayerCache",
+                "ActionInitializeManialinkInteractionHandler",
+                "GbxRemoteClient")
+
+            .ActionAsync("ActionInitializeTemplates", InitializeTemplates, "Manialinks");
+    }
+    
+    private static async Task InitializeTemplates(ServicesBuilder s)
+    {
+        var maniaLinks = s.GetInstance<IManialinkManager>();
+        await maniaLinks.PreprocessAllAsync();
+    }
+
+    private static void MigrateDatabase(ServicesBuilder s)
+    {
+        using var scope = new Scope(s);
+        var manager = scope.GetInstance<IMigrationManager>();
+    
+        // main migrations
+        manager.MigrateFromAssembly(typeof(MigrationManager).Assembly);
+    }
+
+    private static async Task SetupGbxRemoteConnection(ServicesBuilder s)
+    {
+        var serverClient = s.GetInstance<IServerClient>();
+        s.GetInstance<IServerCallbackHandler>();
+        s.GetInstance<IRemoteChatRouter>();
+        await serverClient.StartAsync(CancellationToken.None);
+    }
+}
diff --git a/src/EvoSC.Common/Application/AppFeature.cs b/src/EvoSC.Common/Application/AppFeature.cs
index c3562974a..ee2a3f65a 100644
--- a/src/EvoSC.Common/Application/AppFeature.cs
+++ b/src/EvoSC.Common/Application/AppFeature.cs
@@ -1,24 +1,62 @@
-namespace EvoSC.Common.Application;
+using EvoSC.Common.Util.EnumIdentifier;
+
+namespace EvoSC.Common.Application;
 
 public enum AppFeature
 {
     All,
+    
+    [Identifier(NoPrefix = true)]
     Config,
+    
+    [Identifier(NoPrefix = true)]
     Logging,
+    
+    [Identifier(NoPrefix = true)]
     DatabaseMigrations,
+    
+    [Identifier(NoPrefix = true)]
     Database,
+    
+    [Identifier(NoPrefix = true)]
     Events,
+    
+    [Identifier(NoPrefix = true)]
     GbxRemoteClient,
+    
+    [Identifier(NoPrefix = true)]
     Modules,
+    
+    [Identifier(NoPrefix = true)]
     ControllerManager,
+    
+    [Identifier(NoPrefix = true)]
     PlayerManager,
+    
+    [Identifier(NoPrefix = true)]
     MapsManager,
+    
+    [Identifier(NoPrefix = true)]
     PlayerCache,
+    
+    [Identifier(NoPrefix = true)]
     MatchSettings,
+    
+    [Identifier(NoPrefix = true)]
     Auditing,
+    
+    [Identifier(NoPrefix = true)]
     ServicesManager,
+    
+    [Identifier(NoPrefix = true)]
     ChatCommands,
+    
+    [Identifier(NoPrefix = true)]
     ActionPipelines,
+    
+    [Identifier(NoPrefix = true)]
     Permissions,
+    
+    [Identifier(NoPrefix = true)]
     Manialinks
 }
diff --git a/src/EvoSC.Common/Application/Models/ActionStartupComponent.cs b/src/EvoSC.Common/Application/Models/ActionStartupComponent.cs
new file mode 100644
index 000000000..333a9e5a6
--- /dev/null
+++ b/src/EvoSC.Common/Application/Models/ActionStartupComponent.cs
@@ -0,0 +1,10 @@
+using EvoSC.Common.Interfaces.Application;
+
+namespace EvoSC.Common.Application.Models;
+
+public class ActionStartupComponent : IActionStartupComponent
+{
+    public required string Name { get; init; }
+    public required List<string> Dependencies { get; init; }
+    public required Action<ServicesBuilder> Action { get; init; }
+}
diff --git a/src/EvoSC.Common/Application/Models/AsyncActionStartupComponent.cs b/src/EvoSC.Common/Application/Models/AsyncActionStartupComponent.cs
new file mode 100644
index 000000000..d55e20374
--- /dev/null
+++ b/src/EvoSC.Common/Application/Models/AsyncActionStartupComponent.cs
@@ -0,0 +1,10 @@
+using EvoSC.Common.Interfaces.Application;
+
+namespace EvoSC.Common.Application.Models;
+
+public class AsyncActionStartupComponent : IAsyncActionStartupComponent
+{
+    public required string Name { get; init; }
+    public required List<string> Dependencies { get; init; }
+    public required Func<ServicesBuilder, Task> AsyncAction { get; init; }
+}
diff --git a/src/EvoSC.Common/Application/Models/ServiceStartupComponent.cs b/src/EvoSC.Common/Application/Models/ServiceStartupComponent.cs
new file mode 100644
index 000000000..9957b9aab
--- /dev/null
+++ b/src/EvoSC.Common/Application/Models/ServiceStartupComponent.cs
@@ -0,0 +1,10 @@
+using EvoSC.Common.Interfaces.Application;
+
+namespace EvoSC.Common.Application.Models;
+
+public class ServiceStartupComponent : IServiceStartupComponent
+{
+    public required string Name { get; init; }
+    public required List<string> Dependencies { get; init; }
+    public required Action<ServicesBuilder> ConfigAction { get; init; }
+}
diff --git a/src/EvoSC.Common/Application/ServicesBuilder.cs b/src/EvoSC.Common/Application/ServicesBuilder.cs
index 37618d4e2..790c0671b 100644
--- a/src/EvoSC.Common/Application/ServicesBuilder.cs
+++ b/src/EvoSC.Common/Application/ServicesBuilder.cs
@@ -4,8 +4,4 @@ namespace EvoSC.Common.Application;
 
 public class ServicesBuilder : Container
 {
-    public ServicesBuilder DependsOn(params string[] dependencies)
-    {
-        return this;
-    }
 }
diff --git a/src/EvoSC.Common/Application/StartupPipeline.cs b/src/EvoSC.Common/Application/StartupPipeline.cs
index 374bf4581..3c9fba8bc 100644
--- a/src/EvoSC.Common/Application/StartupPipeline.cs
+++ b/src/EvoSC.Common/Application/StartupPipeline.cs
@@ -1,5 +1,9 @@
-using EvoSC.Common.Config.Models;
+using EvoSC.Common.Application.Models;
+using EvoSC.Common.Config.Models;
 using EvoSC.Common.Interfaces;
+using EvoSC.Common.Interfaces.Application;
+using EvoSC.Common.Logging;
+using Microsoft.Extensions.Logging;
 using SimpleInjector;
 
 namespace EvoSC.Common.Application;
@@ -8,37 +12,106 @@ public class StartupPipeline : IStartupPipeline
 {
     private readonly IEvoScBaseConfig _config;
     private readonly ServicesBuilder _services;
-
+    private readonly ILogger<StartupPipeline> _logger;
+    private readonly Dictionary<string, IStartupComponent> _components = new();
+    
     public StartupPipeline(IEvoScBaseConfig config)
     {
         _config = config;
         _services = new ServicesBuilder();
+
+        _logger = new Container().AddEvoScLogging(config.Logging).GetInstance<ILogger<StartupPipeline>>();
     }
 
     public Container ServiceContainer => _services;
+    
+    public IStartupPipeline Services(string name, Action<ServicesBuilder> servicesConfig, params string[] dependencies)
+    {
+        _components[name] = new ServiceStartupComponent
+        {
+            Name = name, Dependencies = dependencies.ToList(), ConfigAction = servicesConfig
+        };
+
+        return this;
+    }
 
-    public IStartupPipeline Services(string name, Action<ServicesBuilder> servicesConfig)
+    public IStartupPipeline Action(string name, Action<ServicesBuilder> action, params string[] dependencies)
     {
-        throw new NotImplementedException();
+        _components[name] = new ActionStartupComponent
+        {
+            Name = name, Dependencies = dependencies.ToList(), Action = action
+        };
+        
+        return this;
     }
 
-    public IStartupPipeline Action(string name, Action<ServicesBuilder> action)
+    public IStartupPipeline ActionAsync(string name, Func<ServicesBuilder, Task> action, params string[] dependencies)
     {
-        throw new NotImplementedException();
+        _components[name] = new AsyncActionStartupComponent
+        {
+            Name = name, Dependencies = dependencies.ToList(), AsyncAction = action
+        };
+
+        return this;
     }
 
-    public IStartupPipeline ActionAsync(string name, Func<ServicesBuilder, Task> action)
+    private async Task ExecuteComponentAsync(IStartupComponent component)
     {
-        throw new NotImplementedException();
+        _logger.LogDebug("Executing startup component {Name}", component.Name);
+        
+        if (component is IServiceStartupComponent serviceComponent)
+        {
+            serviceComponent.ConfigAction(_services);
+        }
+        else if (component is IActionStartupComponent actionComponent)
+        {
+            actionComponent.Action(_services);
+        }
+        else if (component is IAsyncActionStartupComponent asyncActionComponent)
+        {
+            await asyncActionComponent.AsyncAction(_services);
+        }
     }
+    
+    private async Task ExecuteAsyncInternal(IEnumerable<string> components, List<string> dependencyPath)
+    {
+        foreach (var name in components)
+        {
+            if (dependencyPath.Contains(name))
+            {
+                throw new InvalidOperationException(
+                    $"Startup dependency cycle detected: {string.Join(" -> ", dependencyPath)}");
+            }
+            
+            if (_components.TryGetValue(name, out var component))
+            {
+                if (component.Dependencies.Count > 0)
+                {
+                    var newPath = new List<string>();
+                    newPath.AddRange(dependencyPath);
+                    newPath.Add(name);
+                    await ExecuteAsyncInternal(component.Dependencies.ToArray(), newPath);
+                }
 
+                await ExecuteComponentAsync(component);
+            }
+            else
+            {
+                throw new InvalidOperationException($"Startup component {name} does not exist.");
+            }
+        }
+    }
+    
     public Task ExecuteAsync(params string[] components)
     {
-        throw new NotImplementedException();
+        return ExecuteAsyncInternal(components, Array.Empty<string>().ToList());
     }
 
-    public Task ExecuteAllAsync()
+    public async Task ExecuteAllAsync()
     {
-        throw new NotImplementedException();
+        foreach (var component in _components.Values)
+        {
+            await ExecuteComponentAsync(component);
+        }
     }
 }
diff --git a/src/EvoSC.Common/Config/Configuration.cs b/src/EvoSC.Common/Config/Configuration.cs
index 4a6c62d24..846872328 100644
--- a/src/EvoSC.Common/Config/Configuration.cs
+++ b/src/EvoSC.Common/Config/Configuration.cs
@@ -17,7 +17,7 @@ public static class Configuration
     /// </summary>
     /// <param name="configFile">The TOML file containing the base config.</param>
     /// <returns></returns>
-    public static IEvoScBaseConfig GetBaseConfig(string configFile, Dictionary<string, object> cliOptions)
+    public static IEvoScBaseConfig GetBaseConfig(string configFile, Dictionary<string, string> cliOptions)
     {
         ConfigMapper.SetupDefaultMappers();
 
@@ -33,5 +33,5 @@ public static IEvoScBaseConfig GetBaseConfig(string configFile, Dictionary<strin
     /// Set up and parse EvoSC's base configuration.
     /// </summary>
     /// <returns></returns>
-    public static IEvoScBaseConfig GetBaseConfig(Dictionary<string, object> cliOptions) => GetBaseConfig(MainConfigFile, cliOptions);
+    public static IEvoScBaseConfig GetBaseConfig(Dictionary<string, string> cliOptions) => GetBaseConfig(MainConfigFile, cliOptions);
 }
diff --git a/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs b/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
index 222e7f969..8786ac7f9 100644
--- a/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
+++ b/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
@@ -6,9 +6,9 @@ namespace EvoSC.Common.Config.Stores;
 public class EvoScBaseConfigStore : IConfigStore
 {
     private readonly TomlConfigStore<IEvoScBaseConfig> _tomlConfigStore;
-    private readonly Dictionary<string, object> _cliOptions;
+    private readonly Dictionary<string, string> _cliOptions;
     
-    public EvoScBaseConfigStore(string path, Dictionary<string, object> cliOptions)
+    public EvoScBaseConfigStore(string path, Dictionary<string, string> cliOptions)
     {
         _cliOptions = cliOptions;
         _tomlConfigStore = new TomlConfigStore<IEvoScBaseConfig>(path);
diff --git a/src/EvoSC.Common/Config/Stores/StoreExtensions.cs b/src/EvoSC.Common/Config/Stores/StoreExtensions.cs
index b28568b3f..9a927699c 100644
--- a/src/EvoSC.Common/Config/Stores/StoreExtensions.cs
+++ b/src/EvoSC.Common/Config/Stores/StoreExtensions.cs
@@ -12,7 +12,7 @@ public static class StoreExtensions
     /// <typeparam name="TInterface">The interface which defines the config options.</typeparam>
     /// <returns></returns>
     public static ConfigurationBuilder<TInterface> UseEvoScConfig<TInterface>(
-        this ConfigurationBuilder<TInterface> builder, string path, Dictionary<string, object> cliOptions) where TInterface : class
+        this ConfigurationBuilder<TInterface> builder, string path, Dictionary<string, string> cliOptions) where TInterface : class
     {
         builder.UseConfigStore(new EvoScBaseConfigStore(path, cliOptions));
         return builder;
diff --git a/src/EvoSC.Common/Interfaces/Application/IActionStartupComponent.cs b/src/EvoSC.Common/Interfaces/Application/IActionStartupComponent.cs
new file mode 100644
index 000000000..94d7814e0
--- /dev/null
+++ b/src/EvoSC.Common/Interfaces/Application/IActionStartupComponent.cs
@@ -0,0 +1,8 @@
+using EvoSC.Common.Application;
+
+namespace EvoSC.Common.Interfaces.Application;
+
+public interface IActionStartupComponent : IStartupComponent
+{
+    public Action<ServicesBuilder> Action { get; }
+}
diff --git a/src/EvoSC.Common/Interfaces/Application/IAsyncActionStartupComponent.cs b/src/EvoSC.Common/Interfaces/Application/IAsyncActionStartupComponent.cs
new file mode 100644
index 000000000..4e326f7db
--- /dev/null
+++ b/src/EvoSC.Common/Interfaces/Application/IAsyncActionStartupComponent.cs
@@ -0,0 +1,8 @@
+using EvoSC.Common.Application;
+
+namespace EvoSC.Common.Interfaces.Application;
+
+public interface IAsyncActionStartupComponent : IStartupComponent
+{
+    public Func<ServicesBuilder, Task> AsyncAction { get; }
+}
diff --git a/src/EvoSC.Common/Interfaces/Application/IServiceStartupComponent.cs b/src/EvoSC.Common/Interfaces/Application/IServiceStartupComponent.cs
new file mode 100644
index 000000000..4d09a1d8f
--- /dev/null
+++ b/src/EvoSC.Common/Interfaces/Application/IServiceStartupComponent.cs
@@ -0,0 +1,8 @@
+using EvoSC.Common.Application;
+
+namespace EvoSC.Common.Interfaces.Application;
+
+public interface IServiceStartupComponent : IStartupComponent
+{
+    public Action<ServicesBuilder> ConfigAction { get; }
+}
diff --git a/src/EvoSC.Common/Interfaces/Application/IStartupComponent.cs b/src/EvoSC.Common/Interfaces/Application/IStartupComponent.cs
new file mode 100644
index 000000000..7df1f5c46
--- /dev/null
+++ b/src/EvoSC.Common/Interfaces/Application/IStartupComponent.cs
@@ -0,0 +1,7 @@
+namespace EvoSC.Common.Interfaces.Application;
+
+public interface IStartupComponent
+{
+    public string Name { get; }
+    public List<string> Dependencies { get; }
+}
diff --git a/src/EvoSC.Common/Interfaces/IStartupPipeline.cs b/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
index 7297a3a19..bcd96244f 100644
--- a/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
+++ b/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
@@ -9,16 +9,19 @@ public interface IStartupPipeline
 {
     public Container ServiceContainer { get; }
     
-    public IStartupPipeline Services(string name, Action<ServicesBuilder> servicesConfig);
+    public IStartupPipeline Services(string name, Action<ServicesBuilder> servicesConfig, params string[] dependencies);
 
-    public IStartupPipeline Services(Enum name, Action<ServicesBuilder> servicesConfig) =>
-        Services(name.GetIdentifier(), servicesConfig);
-    public IStartupPipeline Action(string name, Action<ServicesBuilder> action);
-    public IStartupPipeline Action(Enum name, Action<ServicesBuilder> action) => Action(name.GetIdentifier(), action);
-    public IStartupPipeline ActionAsync(string name, Func<ServicesBuilder, Task> action);
+    public IStartupPipeline Services(Enum name, Action<ServicesBuilder> servicesConfig, params string[] dependencies) =>
+        Services(name.GetIdentifier(), servicesConfig, dependencies);
+    public IStartupPipeline Action(string name, Action<ServicesBuilder> action, params string[] dependencies);
 
-    public IStartupPipeline ActionAsync(Enum name, Func<ServicesBuilder, Task> action) =>
-        ActionAsync(name.GetIdentifier(), action);
+    public IStartupPipeline Action(Enum name, Action<ServicesBuilder> action, params string[] dependencies) =>
+        Action(name.GetIdentifier(), action, dependencies);
+    
+    public IStartupPipeline ActionAsync(string name, Func<ServicesBuilder, Task> action, params string[] dependencies);
+
+    public IStartupPipeline ActionAsync(Enum name, Func<ServicesBuilder, Task> action, params string[] dependencies) =>
+        ActionAsync(name.GetIdentifier(), action, dependencies);
 
     public Task ExecuteAsync(params string[] components);
     public Task ExecuteAllAsync();
diff --git a/src/EvoSC.Common/Logging/LoggingServiceExtensions.cs b/src/EvoSC.Common/Logging/LoggingServiceExtensions.cs
index 2da3f8e23..981a9ec1b 100644
--- a/src/EvoSC.Common/Logging/LoggingServiceExtensions.cs
+++ b/src/EvoSC.Common/Logging/LoggingServiceExtensions.cs
@@ -41,8 +41,7 @@ public static Container AddEvoScLogging(this Container services, ILoggingConfig
                 });
             }
         });
-        
-        
+
         services.RegisterInstance<ILoggerFactory>(loggerFactory);
         services.RegisterSingleton(typeof(ILogger<>), typeof(Logger<>));
         
diff --git a/src/EvoSC.Common/Util/ReflectionUtils.cs b/src/EvoSC.Common/Util/ReflectionUtils.cs
index 3677bd54b..35c1e4aab 100644
--- a/src/EvoSC.Common/Util/ReflectionUtils.cs
+++ b/src/EvoSC.Common/Util/ReflectionUtils.cs
@@ -97,7 +97,7 @@ public static bool IsControllerClass(this Type controllerType)
     /// <param name="methodName">Name of the method to call.</param>
     /// <param name="args">Arguments to pass to the method.</param>
     /// <returns></returns>
-    public static object? CallMethod(object instance, string methodName, params object[] args)
+    public static object? CallMethod(object instance, string methodName, params object?[] args)
     {
         var method = instance.GetType().GetMethod(methodName);
         
diff --git a/src/EvoSC/Application.cs b/src/EvoSC/Application.cs
index 91ea1d48f..74ad38448 100644
--- a/src/EvoSC/Application.cs
+++ b/src/EvoSC/Application.cs
@@ -69,7 +69,7 @@ public async Task RunAsync()
     {
         // await SetupApplicationAsync();
         
-        StartupPipeline.SetupBasePipeline(_config);
+        StartupPipeline.SetupPipeline(_config);
         await StartupPipeline.ExecuteAllAsync();
 
         // wait indefinitely
diff --git a/src/EvoSC.CLI/BaseStartup.cs b/src/EvoSC/ApplicationSetup.cs
similarity index 85%
rename from src/EvoSC.CLI/BaseStartup.cs
rename to src/EvoSC/ApplicationSetup.cs
index aef2e89ce..df447ca52 100644
--- a/src/EvoSC.CLI/BaseStartup.cs
+++ b/src/EvoSC/ApplicationSetup.cs
@@ -22,20 +22,21 @@
 using EvoSC.Modules.Util;
 using SimpleInjector;
 
-namespace EvoSC.CLI;
+namespace EvoSC;
 
-public static class BaseStartup
+public static class ApplicationSetup
 {
-    public static void SetupBasePipeline(this IStartupPipeline pipeline, IEvoScBaseConfig config)
+    public static void SetupPipeline(this IStartupPipeline pipeline, IEvoScBaseConfig config)
     {
         pipeline
+            .Services(AppFeature.Config, s => s.RegisterInstance(config))
+
             .Services(AppFeature.Logging, s => s.AddEvoScLogging(config.Logging))
 
             .Services(AppFeature.DatabaseMigrations, s => s.AddEvoScMigrations())
 
             .Services(AppFeature.Database, s => s
-                .DependsOn("DatabaseMigrations")
-                .AddEvoScDatabase(config.Database)
+                    .AddEvoScDatabase(config.Database)
             )
 
             .Services(AppFeature.Events, s => s.AddEvoScEvents())
@@ -85,30 +86,26 @@ public static void SetupBasePipeline(this IStartupPipeline pipeline, IEvoScBaseC
             .ActionAsync("ActionSetupModules", SetupModules)
 
             .Action("ActionInitializeEventManager", s => s
-                .DependsOn("Events")
                 .GetInstance<IEventManager>()
             )
 
             .Action("ActionInitializePlayerCache", s => s
-                .DependsOn("PlayerCache")
                 .GetInstance<IPlayerCacheService>()
             )
 
             .Action("ActionInitializeManialinkInteractionHandler", s => s
-                .DependsOn("ActionInitializeEventManager", "ActionInitializePlayerCache")
+                .GetInstance<IManialinkInteractionHandler>()
             )
-            
+
             .ActionAsync("InitializeGbxRemoteConnection", SetupGbxRemoteConnection)
-            
+
             .ActionAsync("ActionEnableModules", EnableModules)
-            
-            .ActionAsync("ActionInitializeTemplates", InitializeTemplates);
+
+            .ActionAsync("ActionInitializeTemplates", InitializeTemplates, "Manialinks");
     }
     
     private static async Task InitializeTemplates(ServicesBuilder s)
     {
-        s.DependsOn("Manialinks");
-    
         var maniaLinks = s.GetInstance<IManialinkManager>();
         await maniaLinks.PreprocessAllAsync();
     }
@@ -121,7 +118,6 @@ private static async Task EnableModules(ServicesBuilder s)
 
     private static void MigrateDatabase(ServicesBuilder s)
     {
-        s.DependsOn("DatabaseMigrations");
         using var scope = new Scope(s);
         var manager = scope.GetInstance<IMigrationManager>();
     
@@ -129,13 +125,11 @@ private static void MigrateDatabase(ServicesBuilder s)
         manager.MigrateFromAssembly(typeof(MigrationManager).Assembly);
     
         // internal modules
-        // manager.RunInternalModuleMigrations();
+        manager.RunInternalModuleMigrations();
     }
 
     private static void SetupControllerManager(ServicesBuilder s)
     {
-        s.DependsOn("ControllerManager", "ActionPipelines");
-
         var controllers = s.GetInstance<IControllerManager>();
         controllers.AddControllerActionRegistry(s.GetInstance<IEventManager>());
         controllers.AddControllerActionRegistry(s.GetInstance<IChatCommandManager>());
@@ -148,12 +142,10 @@ private static void SetupControllerManager(ServicesBuilder s)
 
     private static async Task SetupModules(ServicesBuilder s)
     {
-        s.DependsOn("Modules", "Config");
-
         var modules = s.GetInstance<IModuleManager>();
         var config = s.GetInstance<IEvoScBaseConfig>();
 
-        // await modules.LoadInternalModulesAsync();
+        await modules.LoadInternalModulesAsync();
 
         var dirs = config.Modules.ModuleDirectories;
         var externalModules = new SortedModuleCollection<IExternalModuleInfo>();
@@ -173,13 +165,6 @@ private static async Task SetupModules(ServicesBuilder s)
 
     private static async Task SetupGbxRemoteConnection(ServicesBuilder s)
     {
-        s.DependsOn(
-            "ActionInitializeEventManager",
-            "ActionInitializePlayerCache",
-            "ActionInitializeManialinkInteractionHandler",
-            "GbxRemoteClient"
-        );
-
         var serverClient = s.GetInstance<IServerClient>();
         s.GetInstance<IServerCallbackHandler>();
         s.GetInstance<IRemoteChatRouter>();
diff --git a/src/EvoSC/CliCommands/RunCommand.cs b/src/EvoSC/CliCommands/RunCommand.cs
index 66ed3b32d..48e41ba2d 100644
--- a/src/EvoSC/CliCommands/RunCommand.cs
+++ b/src/EvoSC/CliCommands/RunCommand.cs
@@ -1,8 +1,6 @@
-using EvoSC.CLI;
-using EvoSC.CLI.Attributes;
+using EvoSC.CLI.Attributes;
 using EvoSC.CLI.Models;
 using EvoSC.Common.Application;
-using EvoSC.Common.Config;
 using EvoSC.Common.Config.Models;
 
 namespace EvoSC.CliCommands;

From a03738cd4d50d760a74f0695565c1e2fc1525b11 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Sat, 1 Jul 2023 11:40:19 +0200
Subject: [PATCH 03/22] startup pipeline tests

---
 .../StartupDependencyCycleException.cs        |   9 ++
 .../Exceptions/StartupPipelineException.cs    |  16 +++
 .../Application/StartupPipeline.cs            |   8 +-
 tests/EvoSC.CLI.Tests/CliHandlerTests.cs      |   6 -
 .../Application/ActionExecutedException.cs    |   8 ++
 .../Application/StartupPipelineTests.cs       | 119 ++++++++++++++++++
 .../Application/TestObjects/IMyService.cs     |   6 +
 .../Application/TestObjects/IMyService2.cs    |   6 +
 .../Application/TestObjects/MyService.cs      |   9 ++
 .../Application/TestObjects/MyService2.cs     |   6 +
 .../Events/EventManagerTests.cs               |  15 ++-
 .../EvoSC.Common.Tests.csproj                 |   1 -
 12 files changed, 192 insertions(+), 17 deletions(-)
 create mode 100644 src/EvoSC.Common/Application/Exceptions/StartupDependencyCycleException.cs
 create mode 100644 src/EvoSC.Common/Application/Exceptions/StartupPipelineException.cs
 create mode 100644 tests/EvoSC.Common.Tests/Application/ActionExecutedException.cs
 create mode 100644 tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs
 create mode 100644 tests/EvoSC.Common.Tests/Application/TestObjects/IMyService.cs
 create mode 100644 tests/EvoSC.Common.Tests/Application/TestObjects/IMyService2.cs
 create mode 100644 tests/EvoSC.Common.Tests/Application/TestObjects/MyService.cs
 create mode 100644 tests/EvoSC.Common.Tests/Application/TestObjects/MyService2.cs

diff --git a/src/EvoSC.Common/Application/Exceptions/StartupDependencyCycleException.cs b/src/EvoSC.Common/Application/Exceptions/StartupDependencyCycleException.cs
new file mode 100644
index 000000000..50c6720f1
--- /dev/null
+++ b/src/EvoSC.Common/Application/Exceptions/StartupDependencyCycleException.cs
@@ -0,0 +1,9 @@
+namespace EvoSC.Common.Application.Exceptions;
+
+public class StartupDependencyCycleException : StartupPipelineException
+{
+    public StartupDependencyCycleException(IEnumerable<string> dependencyPath) : 
+        base($"Startup dependency cycle detected: {string.Join(" -> ", dependencyPath)}")
+    {
+    }
+}
diff --git a/src/EvoSC.Common/Application/Exceptions/StartupPipelineException.cs b/src/EvoSC.Common/Application/Exceptions/StartupPipelineException.cs
new file mode 100644
index 000000000..28b0cd51b
--- /dev/null
+++ b/src/EvoSC.Common/Application/Exceptions/StartupPipelineException.cs
@@ -0,0 +1,16 @@
+namespace EvoSC.Common.Application.Exceptions;
+
+public class StartupPipelineException : Exception
+{
+    public StartupPipelineException()
+    {
+    }
+
+    public StartupPipelineException(string? message) : base(message)
+    {
+    }
+
+    public StartupPipelineException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
+}
diff --git a/src/EvoSC.Common/Application/StartupPipeline.cs b/src/EvoSC.Common/Application/StartupPipeline.cs
index 3c9fba8bc..11d146286 100644
--- a/src/EvoSC.Common/Application/StartupPipeline.cs
+++ b/src/EvoSC.Common/Application/StartupPipeline.cs
@@ -1,4 +1,5 @@
-using EvoSC.Common.Application.Models;
+using EvoSC.Common.Application.Exceptions;
+using EvoSC.Common.Application.Models;
 using EvoSC.Common.Config.Models;
 using EvoSC.Common.Interfaces;
 using EvoSC.Common.Interfaces.Application;
@@ -79,8 +80,7 @@ private async Task ExecuteAsyncInternal(IEnumerable<string> components, List<str
         {
             if (dependencyPath.Contains(name))
             {
-                throw new InvalidOperationException(
-                    $"Startup dependency cycle detected: {string.Join(" -> ", dependencyPath)}");
+                throw new StartupDependencyCycleException(dependencyPath);
             }
             
             if (_components.TryGetValue(name, out var component))
@@ -97,7 +97,7 @@ private async Task ExecuteAsyncInternal(IEnumerable<string> components, List<str
             }
             else
             {
-                throw new InvalidOperationException($"Startup component {name} does not exist.");
+                throw new StartupPipelineException($"Startup component {name} does not exist.");
             }
         }
     }
diff --git a/tests/EvoSC.CLI.Tests/CliHandlerTests.cs b/tests/EvoSC.CLI.Tests/CliHandlerTests.cs
index 66d36ef82..8522d7ae2 100644
--- a/tests/EvoSC.CLI.Tests/CliHandlerTests.cs
+++ b/tests/EvoSC.CLI.Tests/CliHandlerTests.cs
@@ -1,9 +1,3 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using EvoSC.CLI.Attributes;
-using EvoSC.CLI.Exceptions;
-using EvoSC.CLI.Interfaces;
 using Xunit;
 
 namespace EvoSC.CLI.Tests;
diff --git a/tests/EvoSC.Common.Tests/Application/ActionExecutedException.cs b/tests/EvoSC.Common.Tests/Application/ActionExecutedException.cs
new file mode 100644
index 000000000..c4359af34
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Application/ActionExecutedException.cs
@@ -0,0 +1,8 @@
+using System;
+
+namespace EvoSC.Common.Tests.Application;
+
+public class ActionExecutedException : Exception
+{
+    
+}
diff --git a/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs b/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs
new file mode 100644
index 000000000..f3ec57a94
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs
@@ -0,0 +1,119 @@
+using System;
+using System.Threading.Tasks;
+using EvoSC.Common.Application;
+using EvoSC.Common.Application.Exceptions;
+using EvoSC.Common.Config.Models;
+using EvoSC.Common.Tests.Application.TestObjects;
+using Moq;
+using SimpleInjector;
+using Xunit;
+
+namespace EvoSC.Common.Tests.Application;
+
+public class StartupPipelineTests
+{
+    private Mock<IEvoScBaseConfig> _config;
+
+    public StartupPipelineTests()
+    {
+        var loggingMock = new Mock<ILoggingConfig>();
+        loggingMock.Setup(l => l.LogLevel).Returns("info");
+        _config = new Mock<IEvoScBaseConfig>();
+        _config.Setup(c => c.Logging).Returns(loggingMock.Object);
+    }
+    
+    [Fact]
+    public async Task Simple_Service_Is_Set_Up()
+    {
+        var startup = new StartupPipeline(_config.Object);
+        startup.Services("TestService", s => s
+            .Register<IMyService, MyService>()
+        );
+
+        await startup.ExecuteAsync("TestService");
+
+        var service = startup.ServiceContainer.GetInstance<IMyService>();
+        Assert.NotNull(service);
+    }
+
+    [Fact]
+    public async Task Dependency_Is_Also_Executed()
+    {
+        var startup = new StartupPipeline(_config.Object);
+        startup.Services("TestService", s => s
+            .Register<IMyService, MyService>()
+        );
+        startup.Services("TestService2", s => s
+                .Register<IMyService2, MyService2>()
+            , "TestService");
+
+        await startup.ExecuteAsync("TestService2");
+        
+        var service = startup.ServiceContainer.GetInstance<IMyService>();
+        Assert.NotNull(service);
+    }
+    
+    [Fact]
+    public async Task Only_Specified_Component_Is_Executed()
+    {
+        var startup = new StartupPipeline(_config.Object);
+        startup.Services("TestService", s => s
+            .Register<IMyService, MyService>()
+        );
+        startup.Services("TestService2", s => s
+                .Register<IMyService2, MyService2>()
+        );
+
+        await startup.ExecuteAsync("TestService");
+        
+        var service = startup.ServiceContainer.GetInstance<IMyService>();
+
+        Assert.NotNull(service);
+        Assert.Throws<ActivationException>(() => startup.ServiceContainer.GetInstance<IMyService2>());
+    }
+
+    [Fact]
+    public async Task All_Components_Are_Executed()
+    {
+        var startup = new StartupPipeline(_config.Object);
+        var actionExecuted = false;
+        var asyncActionExecuted = true;
+        
+        startup.Services("TestService", s => s.Register<IMyService, MyService>());
+        startup.Action("MyAction", s => actionExecuted = true);
+        startup.ActionAsync("MyAsyncAction", s =>
+        {
+            asyncActionExecuted = true;
+            return Task.CompletedTask;
+        });
+
+        await startup.ExecuteAllAsync();
+
+        var service = startup.ServiceContainer.GetInstance<IMyService>();
+        
+        Assert.NotNull(service);
+        Assert.True(actionExecuted);
+        Assert.True(asyncActionExecuted);
+    }
+
+    [Fact]
+    public async Task Dependency_Cycle_Detected_Throws_Exception()
+    {
+        var startup = new StartupPipeline(_config.Object);
+        startup.Services("TestService", s => s
+            .Register<IMyService, MyService>()
+        , "TestService2");
+        startup.Services("TestService2", s => s
+            .Register<IMyService2, MyService2>()
+        , "TestService");
+
+        await Assert.ThrowsAsync<StartupDependencyCycleException>(() => startup.ExecuteAsync("TestService"));
+    }
+
+    [Fact]
+    public async Task Startup_Component_Not_Existing_Throws_Exception()
+    {
+        var startup = new StartupPipeline(_config.Object);
+        await Assert.ThrowsAsync<StartupPipelineException>(() => startup.ExecuteAsync("InvalidComponent"));
+    }
+}
diff --git a/tests/EvoSC.Common.Tests/Application/TestObjects/IMyService.cs b/tests/EvoSC.Common.Tests/Application/TestObjects/IMyService.cs
new file mode 100644
index 000000000..8cf0a2ea4
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Application/TestObjects/IMyService.cs
@@ -0,0 +1,6 @@
+namespace EvoSC.Common.Tests.Application.TestObjects;
+
+public interface IMyService
+{
+    public void MyMethod();
+}
diff --git a/tests/EvoSC.Common.Tests/Application/TestObjects/IMyService2.cs b/tests/EvoSC.Common.Tests/Application/TestObjects/IMyService2.cs
new file mode 100644
index 000000000..0e8f47db1
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Application/TestObjects/IMyService2.cs
@@ -0,0 +1,6 @@
+namespace EvoSC.Common.Tests.Application.TestObjects;
+
+public interface IMyService2
+{
+    
+}
diff --git a/tests/EvoSC.Common.Tests/Application/TestObjects/MyService.cs b/tests/EvoSC.Common.Tests/Application/TestObjects/MyService.cs
new file mode 100644
index 000000000..e19147860
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Application/TestObjects/MyService.cs
@@ -0,0 +1,9 @@
+namespace EvoSC.Common.Tests.Application.TestObjects;
+
+public class MyService : IMyService
+{
+    public void MyMethod()
+    {
+        
+    }
+}
diff --git a/tests/EvoSC.Common.Tests/Application/TestObjects/MyService2.cs b/tests/EvoSC.Common.Tests/Application/TestObjects/MyService2.cs
new file mode 100644
index 000000000..b2a410f15
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Application/TestObjects/MyService2.cs
@@ -0,0 +1,6 @@
+namespace EvoSC.Common.Tests.Application.TestObjects;
+
+public class MyService2 : IMyService2
+{
+    
+}
diff --git a/tests/EvoSC.Common.Tests/Events/EventManagerTests.cs b/tests/EvoSC.Common.Tests/Events/EventManagerTests.cs
index e250e2c3b..694d6e24b 100644
--- a/tests/EvoSC.Common.Tests/Events/EventManagerTests.cs
+++ b/tests/EvoSC.Common.Tests/Events/EventManagerTests.cs
@@ -4,6 +4,8 @@
 using EvoSC.Common.Interfaces;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Moq;
+using SimpleInjector;
 using Xunit;
 
 namespace EvoSC.Common.Tests.Events;
@@ -15,19 +17,20 @@ class HandlerRanException2 : Exception {}
 
     private readonly ILogger<EventManager> _logger;
     private readonly IServiceProvider _services;
-    private readonly IEvoSCApplication _app;
+    private readonly Mock<IEvoSCApplication> _app;
 
     public EventManagerTests()
     {
         _logger = LoggerFactory.Create(c => { }).CreateLogger<EventManager>();
         _services = new ServiceCollection().BuildServiceProvider();
-        _app = new Application(Array.Empty<string>());
+        _app = new Mock<IEvoSCApplication>();
+        _app.Setup(a => a.Services).Returns(new Container());
     }
     
     [Fact]
     public async Task Event_Added_AndFired_Dont_Throw_Exception()
     {
-        IEventManager manager = new EventManager(_logger, _app, null);
+        IEventManager manager = new EventManager(_logger, _app.Object, null);
 
         manager.Subscribe("test", (object sender, EventArgs args) =>
         {
@@ -42,7 +45,7 @@ public async Task Event_Added_AndFired_Dont_Throw_Exception()
     [Fact]
     public void Event_Added_And_Fired()
     {
-        IEventManager manager = new EventManager(_logger, _app, null);
+        IEventManager manager = new EventManager(_logger, _app.Object, null);
 
         manager.Subscribe<EventArgs>("test", (sender, args) => throw new HandlerRanException());
 
@@ -55,7 +58,7 @@ public void Event_Added_And_Fired()
     [Fact]
     public async Task Event_Added_And_Removed()
     {
-        IEventManager manager = new EventManager(_logger, _app, null);
+        IEventManager manager = new EventManager(_logger, _app.Object, null);
 
         var handler = new AsyncEventHandler<EventArgs>((sender, args) => throw new HandlerRanException());
         
@@ -70,7 +73,7 @@ public async Task Event_Added_And_Removed()
     [Fact]
     public void Only_Equal_Event_Handler_Removed()
     {
-        IEventManager manager = new EventManager(_logger, _app, null);
+        IEventManager manager = new EventManager(_logger, _app.Object, null);
 
         var handler = new AsyncEventHandler<EventArgs>((sender, args) => throw new HandlerRanException());
         var handler2 = new AsyncEventHandler<EventArgs>((sender, args) => throw new HandlerRanException2());
diff --git a/tests/EvoSC.Common.Tests/EvoSC.Common.Tests.csproj b/tests/EvoSC.Common.Tests/EvoSC.Common.Tests.csproj
index c644e3be1..fcfbd4720 100644
--- a/tests/EvoSC.Common.Tests/EvoSC.Common.Tests.csproj
+++ b/tests/EvoSC.Common.Tests/EvoSC.Common.Tests.csproj
@@ -28,7 +28,6 @@
 
     <ItemGroup>
       <ProjectReference Include="..\..\src\EvoSC.Common\EvoSC.Common.csproj" />
-      <ProjectReference Include="..\..\src\EvoSC\EvoSC.csproj" />
     </ItemGroup>
 
     <ItemGroup>

From 802c31216c7a67efd2b53778552d6be7aee3e52d Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Sat, 1 Jul 2023 11:45:01 +0200
Subject: [PATCH 04/22] disable modules before disconnecting from gbxremote

---
 src/EvoSC/Application.cs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/EvoSC/Application.cs b/src/EvoSC/Application.cs
index 74ad38448..225828c0a 100644
--- a/src/EvoSC/Application.cs
+++ b/src/EvoSC/Application.cs
@@ -78,6 +78,13 @@ public async Task RunAsync()
     
     public async Task ShutdownAsync()
     {
+        var moduleManager = Services.GetInstance<IModuleManager>();
+
+        foreach (var module in moduleManager.LoadedModules)
+        {
+            await moduleManager.UnloadAsync(module.LoadId);
+        }
+        
         var serverClient = Services.GetInstance<IServerClient>();
         await serverClient.StopAsync(_runningToken.Token);
         
@@ -215,13 +222,6 @@ private async Task InitializeTemplatesAsync()
 
     public void Dispose()
     {
-        var moduleManager = Services.GetInstance<IModuleManager>();
-
-        foreach (var module in moduleManager.LoadedModules)
-        {
-            moduleManager.UnloadAsync(module.LoadId).GetAwaiter().GetResult();
-        }
-        
         Services.Dispose();
         _runningToken.Dispose();
     }

From 349fb434b5b83b7b2dd5eee5329f71b68457e4aa Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Mon, 3 Jul 2023 13:00:04 +0200
Subject: [PATCH 05/22] cli tests

---
 src/EvoSC.CLI/CliManager.cs                   | 118 ++++++++++++------
 src/EvoSC.CLI/Exceptions/EvoScCliException.cs |  16 +++
 .../InvalidCommandClassFormatException.cs     |   8 ++
 src/EvoSC.CLI/Interfaces/ICliManager.cs       |   1 +
 .../Config/Models/IServerConfig.cs            |   2 +-
 tests/EvoSC.CLI.Tests/CliHandlerTests.cs      |   8 --
 tests/EvoSC.CLI.Tests/CliManagerTests.cs      |  63 ++++++++++
 .../TestClasses/CliOptionsParsedCmdClass.cs   |  26 ++++
 .../TestClasses/CustomOptionType.cs           |  11 ++
 .../TestClasses/InvalidCommandClass.cs        |   6 +
 .../TestClasses/NoAttributeCmdClass.cs        |  11 ++
 .../TestClasses/TestCommandClass.cs           |  15 +++
 12 files changed, 235 insertions(+), 50 deletions(-)
 create mode 100644 src/EvoSC.CLI/Exceptions/EvoScCliException.cs
 create mode 100644 src/EvoSC.CLI/Exceptions/InvalidCommandClassFormatException.cs
 delete mode 100644 tests/EvoSC.CLI.Tests/CliHandlerTests.cs
 create mode 100644 tests/EvoSC.CLI.Tests/CliManagerTests.cs
 create mode 100644 tests/EvoSC.CLI.Tests/TestClasses/CliOptionsParsedCmdClass.cs
 create mode 100644 tests/EvoSC.CLI.Tests/TestClasses/CustomOptionType.cs
 create mode 100644 tests/EvoSC.CLI.Tests/TestClasses/InvalidCommandClass.cs
 create mode 100644 tests/EvoSC.CLI.Tests/TestClasses/NoAttributeCmdClass.cs
 create mode 100644 tests/EvoSC.CLI.Tests/TestClasses/TestCommandClass.cs

diff --git a/src/EvoSC.CLI/CliManager.cs b/src/EvoSC.CLI/CliManager.cs
index a42900aa5..182302040 100644
--- a/src/EvoSC.CLI/CliManager.cs
+++ b/src/EvoSC.CLI/CliManager.cs
@@ -1,22 +1,26 @@
 using System.CommandLine;
+using System.CommandLine.Builder;
 using System.CommandLine.Invocation;
+using System.CommandLine.Parsing;
 using System.ComponentModel;
 using System.Reflection;
 using EvoSC.CLI.Attributes;
+using EvoSC.CLI.Exceptions;
 using EvoSC.CLI.Interfaces;
 using EvoSC.CLI.Models;
 using EvoSC.Common.Application;
 using EvoSC.Common.Config;
 using EvoSC.Common.Util;
 using EvoSC.Common.Util.EnumIdentifier;
-using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.Extensions.DependencyInjection;
+using Org.BouncyCastle.Asn1.X509.Qualified;
 
 namespace EvoSC.CLI;
 
 public class CliManager : ICliManager
 {
     private readonly RootCommand _rootCommand;
+    private readonly Parser _cliParser;
     private readonly Option<IEnumerable<string>> _configOption;
     private readonly List<ICliCommandInfo> _registeredCommands = new();
 
@@ -29,58 +33,83 @@ public CliManager()
                 description: "Override configuration options. Format is key:value");
         
         _rootCommand.AddGlobalOption(_configOption);
+
+        _cliParser = new CommandLineBuilder(_rootCommand)
+            .UseVersionOption()
+            .UseHelp()
+            .UseEnvironmentVariableDirective()
+            .UseParseDirective()
+            .UseSuggestDirective()
+            .RegisterWithDotnetSuggest()
+            .UseTypoCorrections()
+            .UseParseErrorReporting()
+            .CancelOnProcessTermination()
+            .Build();
     }
     
     public ICliManager RegisterCommands(Assembly assembly)
     {
         foreach (var cmdClass in assembly.AssemblyTypesWithAttribute<CliCommandAttribute>())
         {
-            var handlerMethod = cmdClass.GetMethod("ExecuteAsync");
+            RegisterCommand(cmdClass);
+        }
 
-            if (handlerMethod == null)
-            {
-                throw new InvalidOperationException(
-                    $"Did not find the ExecuteAsync method in CLI command: {cmdClass.Name}");
-            }
-            
-            var cmdAttr = cmdClass.GetCustomAttribute<CliCommandAttribute>();
-            var requiredFeatures = cmdClass.GetCustomAttribute<RequiredFeaturesAttribute>();
+        return this;
+    }
 
-            var command = new Command(cmdAttr!.Name, cmdAttr.Description);
+    public ICliManager RegisterCommand(Type cmdClass)
+    {
+        var handlerMethod = cmdClass.GetMethod("ExecuteAsync");
 
-            var options = new List<Option>();
-            foreach (var param in handlerMethod.GetParameters())
-            {
-                var option = CreateOption(param);
+        if (handlerMethod == null)
+        {
+            throw new InvalidCommandClassFormatException(
+                $"Did not find the ExecuteAsync method in CLI command: {cmdClass.Name}");
+        }
+        
+        var cmdAttr = cmdClass.GetCustomAttribute<CliCommandAttribute>();
 
-                if (option == null)
-                {
-                    throw new InvalidOperationException($"Failed to create option for CLI command {cmdClass.Name}");
-                }
+        if (cmdAttr == null)
+        {
+            throw new InvalidCommandClassFormatException("Missing CliCommand");
+        }
+        
+        var requiredFeatures = cmdClass.GetCustomAttribute<RequiredFeaturesAttribute>();
 
-                options.Add(option);
-                command.AddOption(option);
-            }
-            
-            options.Add(_configOption);
+        var command = new Command(cmdAttr!.Name, cmdAttr.Description);
 
-            var commandInfo = new CliCommandInfo
-            {
-                Command = command,
-                CommandClass = cmdClass,
-                HandlerMethod = handlerMethod,
-                Options = options.ToArray(),
-                RequiredFeatures = requiredFeatures?.Features ?? Array.Empty<AppFeature>()
-            };
-
-            command.SetHandler(async context =>
+        var options = new List<Option>();
+        foreach (var param in handlerMethod.GetParameters())
+        {
+            var option = CreateOption(param);
+
+            if (option == null)
             {
-                await ExecuteHandlerAsync(commandInfo, context);
-            });
+                throw new InvalidOperationException($"Failed to create option for CLI command {cmdClass.Name}");
+            }
 
-            _registeredCommands.Add(commandInfo);
-            _rootCommand.AddCommand(command);
+            options.Add(option);
+            command.AddOption(option);
         }
+            
+        options.Add(_configOption);
+
+        var commandInfo = new CliCommandInfo
+        {
+            Command = command,
+            CommandClass = cmdClass,
+            HandlerMethod = handlerMethod,
+            Options = options.ToArray(),
+            RequiredFeatures = requiredFeatures?.Features ?? Array.Empty<AppFeature>()
+        };
+
+        command.SetHandler(async context =>
+        {
+            await ExecuteHandlerAsync(commandInfo, context);
+        });
+
+        _registeredCommands.Add(commandInfo);
+        _rootCommand.AddCommand(command);
 
         return this;
     }
@@ -90,11 +119,17 @@ private async Task ExecuteHandlerAsync(ICliCommandInfo command, InvocationContex
         var paramValues = new List<object?>();
 
         foreach (var option in command.Options)
-        {
+        { 
             if (option == _configOption)
             {
                 continue;
             }
+
+            if (option.ValueType == typeof(InvocationContext))
+            {
+                paramValues.Add(context);
+                continue;
+            }
             
             var optionValue = context.BindingContext.ParseResult.GetValueForOption(option);
             paramValues.Add(optionValue);
@@ -154,13 +189,14 @@ await startupPipeline.ExecuteAsync(command.RequiredFeatures
 
         var description = param.GetCustomAttribute<DescriptionAttribute>();
 
-        var option = Activator.CreateInstance(cmdOptionType, aliases, description?.Description ?? "") as Option;
+        var option = Activator.CreateInstance(cmdOptionType, aliases.ToArray(), description?.Description ?? "") as Option;
 
         return option;
     }
 
     public Task<int> ExecuteAsync(string[] args)
     {
-        return _rootCommand.InvokeAsync(args);
+        // return _rootCommand.InvokeAsync(args);
+        return _cliParser.InvokeAsync(args);
     }
 }
diff --git a/src/EvoSC.CLI/Exceptions/EvoScCliException.cs b/src/EvoSC.CLI/Exceptions/EvoScCliException.cs
new file mode 100644
index 000000000..48dfbb7a2
--- /dev/null
+++ b/src/EvoSC.CLI/Exceptions/EvoScCliException.cs
@@ -0,0 +1,16 @@
+namespace EvoSC.CLI.Exceptions;
+
+public class EvoScCliException : Exception
+{
+    public EvoScCliException()
+    {
+    }
+
+    public EvoScCliException(string? message) : base(message)
+    {
+    }
+
+    public EvoScCliException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
+}
diff --git a/src/EvoSC.CLI/Exceptions/InvalidCommandClassFormatException.cs b/src/EvoSC.CLI/Exceptions/InvalidCommandClassFormatException.cs
new file mode 100644
index 000000000..5bbc58122
--- /dev/null
+++ b/src/EvoSC.CLI/Exceptions/InvalidCommandClassFormatException.cs
@@ -0,0 +1,8 @@
+namespace EvoSC.CLI.Exceptions;
+
+public class InvalidCommandClassFormatException : EvoScCliException
+{
+    public InvalidCommandClassFormatException(string? message) : base(message)
+    {
+    }
+}
diff --git a/src/EvoSC.CLI/Interfaces/ICliManager.cs b/src/EvoSC.CLI/Interfaces/ICliManager.cs
index 4df0d73b2..191e4cd7d 100644
--- a/src/EvoSC.CLI/Interfaces/ICliManager.cs
+++ b/src/EvoSC.CLI/Interfaces/ICliManager.cs
@@ -5,5 +5,6 @@ namespace EvoSC.CLI.Interfaces;
 public interface ICliManager
 {
     public ICliManager RegisterCommands(Assembly assembly);
+    public ICliManager RegisterCommand(Type cmdClass);
     public Task<int> ExecuteAsync(string[] args);
 }
diff --git a/src/EvoSC.Common/Config/Models/IServerConfig.cs b/src/EvoSC.Common/Config/Models/IServerConfig.cs
index aee717eb2..9aa80832e 100644
--- a/src/EvoSC.Common/Config/Models/IServerConfig.cs
+++ b/src/EvoSC.Common/Config/Models/IServerConfig.cs
@@ -6,7 +6,7 @@ namespace EvoSC.Common.Config.Models;
 public interface IServerConfig
 {
     [Description("Address to the Trackmania server")]
-    [Option(Alias = "host", DefaultValue = "172.23.97.27")]
+    [Option(Alias = "host", DefaultValue = "127.0.0.1")]
     public string Host { get; }
     
     [Description("Port that the XMLRPC is listening to")]
diff --git a/tests/EvoSC.CLI.Tests/CliHandlerTests.cs b/tests/EvoSC.CLI.Tests/CliHandlerTests.cs
deleted file mode 100644
index 8522d7ae2..000000000
--- a/tests/EvoSC.CLI.Tests/CliHandlerTests.cs
+++ /dev/null
@@ -1,8 +0,0 @@
-using Xunit;
-
-namespace EvoSC.CLI.Tests;
-
-public class CliHandlerTests
-{
-    
-}
diff --git a/tests/EvoSC.CLI.Tests/CliManagerTests.cs b/tests/EvoSC.CLI.Tests/CliManagerTests.cs
new file mode 100644
index 000000000..adbdc77b5
--- /dev/null
+++ b/tests/EvoSC.CLI.Tests/CliManagerTests.cs
@@ -0,0 +1,63 @@
+using System;
+using System.Threading.Tasks;
+using EvoSC.CLI.Exceptions;
+using EvoSC.CLI.Tests.TestClasses;
+using Xunit;
+
+namespace EvoSC.CLI.Tests;
+
+public class CliManagerTests
+{
+    [Fact]
+    public void Register_Command_Without_Handler_Throws_Exception()
+    {
+        var manager = new CliManager();
+
+        Assert.Throws<InvalidCommandClassFormatException>(() =>
+            manager.RegisterCommand(typeof(InvalidCommandClass))
+        );
+    }
+
+    [Fact]
+    public void No_Attribute_Throws_Exception()
+    {
+        var manager = new CliManager();
+
+        Assert.Throws<InvalidCommandClassFormatException>(() => 
+            manager.RegisterCommand(typeof(NoAttributeCmdClass))
+        );
+    }
+
+    [Fact]
+    public async Task Simple_Command_Registered_And_Executed()
+    {
+        var manager = new CliManager();
+        manager.RegisterCommand(typeof(TestCommandClass));
+
+        var exitCode = await manager.ExecuteAsync(new[] {"Test", "--myarg", "1337"});
+        
+        Assert.Equal(1337, exitCode);
+    }
+
+    [Fact]
+    public async Task Invalid_Cli_Option_Format_Throws_Exception()
+    {
+        var manager = new CliManager();
+        manager.RegisterCommand(typeof(TestCommandClass));
+
+        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            manager.ExecuteAsync(new[] {"Test", "--myarg", "1337", "--option", "invalidformat"})
+        );
+    }
+
+    [Fact]
+    public async Task Config_Option_Is_Parsed_And_Overrides_Default()
+    {
+        var manager = new CliManager();
+        manager.RegisterCommand(typeof(CliOptionsParsedCmdClass));
+
+        await manager.ExecuteAsync(new[] {"Test", "--option", "Server.host:123.456.789.012"});
+        
+        // assert statement in CliOptionsParsedCmdClass ExecuteAsync method
+    }
+}
diff --git a/tests/EvoSC.CLI.Tests/TestClasses/CliOptionsParsedCmdClass.cs b/tests/EvoSC.CLI.Tests/TestClasses/CliOptionsParsedCmdClass.cs
new file mode 100644
index 000000000..040e4bac5
--- /dev/null
+++ b/tests/EvoSC.CLI.Tests/TestClasses/CliOptionsParsedCmdClass.cs
@@ -0,0 +1,26 @@
+using System.Threading.Tasks;
+using EvoSC.CLI.Attributes;
+using EvoSC.Common.Application;
+using EvoSC.Common.Config.Models;
+using Xunit;
+
+namespace EvoSC.CLI.Tests.TestClasses;
+
+[CliCommand(Name = "Test", Description = "")]
+[RequiredFeatures(AppFeature.Config)]
+public class CliOptionsParsedCmdClass
+{
+    private readonly IEvoScBaseConfig _config;
+    
+    public CliOptionsParsedCmdClass(IEvoScBaseConfig config)
+    {
+        _config = config;
+    }
+    
+    public Task ExecuteAsync()
+    {
+        Assert.Equal("123.456.789.012", _config.Server.Host);
+        
+        return Task.CompletedTask;
+    }
+}
diff --git a/tests/EvoSC.CLI.Tests/TestClasses/CustomOptionType.cs b/tests/EvoSC.CLI.Tests/TestClasses/CustomOptionType.cs
new file mode 100644
index 000000000..4fff4e66e
--- /dev/null
+++ b/tests/EvoSC.CLI.Tests/TestClasses/CustomOptionType.cs
@@ -0,0 +1,11 @@
+using System;
+
+namespace EvoSC.CLI.Tests.TestClasses;
+
+public class CustomOptionType
+{
+    public CustomOptionType()
+    {
+        throw new InvalidOperationException();
+    }
+}
diff --git a/tests/EvoSC.CLI.Tests/TestClasses/InvalidCommandClass.cs b/tests/EvoSC.CLI.Tests/TestClasses/InvalidCommandClass.cs
new file mode 100644
index 000000000..3f7f0ea68
--- /dev/null
+++ b/tests/EvoSC.CLI.Tests/TestClasses/InvalidCommandClass.cs
@@ -0,0 +1,6 @@
+namespace EvoSC.CLI.Tests.TestClasses;
+
+public class InvalidCommandClass
+{
+    
+}
diff --git a/tests/EvoSC.CLI.Tests/TestClasses/NoAttributeCmdClass.cs b/tests/EvoSC.CLI.Tests/TestClasses/NoAttributeCmdClass.cs
new file mode 100644
index 000000000..e67948bd6
--- /dev/null
+++ b/tests/EvoSC.CLI.Tests/TestClasses/NoAttributeCmdClass.cs
@@ -0,0 +1,11 @@
+using System.Threading.Tasks;
+
+namespace EvoSC.CLI.Tests.TestClasses;
+
+public class NoAttributeCmdClass
+{
+    public Task ExecuteAsync(int test)
+    {
+        return Task.CompletedTask;
+    }
+}
diff --git a/tests/EvoSC.CLI.Tests/TestClasses/TestCommandClass.cs b/tests/EvoSC.CLI.Tests/TestClasses/TestCommandClass.cs
new file mode 100644
index 000000000..bdfa7e69f
--- /dev/null
+++ b/tests/EvoSC.CLI.Tests/TestClasses/TestCommandClass.cs
@@ -0,0 +1,15 @@
+using System.CommandLine.Invocation;
+using System.Threading.Tasks;
+using EvoSC.CLI.Attributes;
+
+namespace EvoSC.CLI.Tests.TestClasses;
+
+[CliCommand(Name = "Test", Description = "Simple command class.")]
+public class TestCommandClass
+{
+    public Task ExecuteAsync(InvocationContext context, int myarg)
+    {
+        context.ExitCode = myarg;
+        return Task.CompletedTask;
+    }
+}

From 3e4e626bbc7cfd9a87573618c1c188e3f0fd6e93 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Mon, 3 Jul 2023 13:00:25 +0200
Subject: [PATCH 06/22] remove unused class

---
 tests/EvoSC.CLI.Tests/TestClasses/CustomOptionType.cs | 11 -----------
 1 file changed, 11 deletions(-)
 delete mode 100644 tests/EvoSC.CLI.Tests/TestClasses/CustomOptionType.cs

diff --git a/tests/EvoSC.CLI.Tests/TestClasses/CustomOptionType.cs b/tests/EvoSC.CLI.Tests/TestClasses/CustomOptionType.cs
deleted file mode 100644
index 4fff4e66e..000000000
--- a/tests/EvoSC.CLI.Tests/TestClasses/CustomOptionType.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using System;
-
-namespace EvoSC.CLI.Tests.TestClasses;
-
-public class CustomOptionType
-{
-    public CustomOptionType()
-    {
-        throw new InvalidOperationException();
-    }
-}

From 3e70821644262950b048dfa4ebc748e678d3f382 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Tue, 4 Jul 2023 17:52:34 +0200
Subject: [PATCH 07/22] required features attribute tests

---
 .../RequiredFeaturesAttributeTests.cs         | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tests/EvoSC.CLI.Tests/RequiredFeaturesAttributeTests.cs

diff --git a/tests/EvoSC.CLI.Tests/RequiredFeaturesAttributeTests.cs b/tests/EvoSC.CLI.Tests/RequiredFeaturesAttributeTests.cs
new file mode 100644
index 000000000..043e85ca6
--- /dev/null
+++ b/tests/EvoSC.CLI.Tests/RequiredFeaturesAttributeTests.cs
@@ -0,0 +1,57 @@
+using EvoSC.CLI.Attributes;
+using EvoSC.Common.Application;
+using Xunit;
+
+namespace EvoSC.CLI.Tests;
+
+public class RequiredFeaturesAttributeTests
+{
+    [Fact]
+    public void Single_Feature_Provided()
+    {
+        var attr = new RequiredFeaturesAttribute(AppFeature.Auditing);
+
+        Assert.Contains(AppFeature.Auditing, attr.Features);
+    }
+
+    [Fact]
+    public void Multiple_Features_Is_Combined()
+    {
+        var attr = new RequiredFeaturesAttribute(AppFeature.Auditing, AppFeature.Config, AppFeature.Database);
+
+        Assert.Equal(new AppFeature[]
+        {
+            AppFeature.Auditing, 
+            AppFeature.Config, 
+            AppFeature.Database
+        }, attr.Features);
+    }
+
+    [Fact]
+    public void All_Features_Enum_Adds_All_Features()
+    {
+        var attr = new RequiredFeaturesAttribute(AppFeature.All);
+        
+        Assert.Equal(new AppFeature[]
+        {
+            AppFeature.Config,
+            AppFeature.Logging,
+            AppFeature.DatabaseMigrations,
+            AppFeature.Database,
+            AppFeature.Events,
+            AppFeature.GbxRemoteClient,
+            AppFeature.Modules,
+            AppFeature.ControllerManager,
+            AppFeature.PlayerManager,
+            AppFeature.MapsManager,
+            AppFeature.PlayerCache,
+            AppFeature.MatchSettings,
+            AppFeature.Auditing,
+            AppFeature.ServicesManager,
+            AppFeature.ChatCommands,
+            AppFeature.ActionPipelines,
+            AppFeature.Permissions,
+            AppFeature.Manialinks,
+        }, attr.Features);
+    }
+}

From 035d62b579b55725e1b111a37472cf2e9bfb2547 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Tue, 4 Jul 2023 18:15:43 +0200
Subject: [PATCH 08/22] TextColorTypeParser tests

---
 .../Config/Mapping/TextColorTypeParser.cs     | 18 ++++--
 .../Mapping/TextColorTypeParserTests.cs       | 62 +++++++++++++++++++
 2 files changed, 75 insertions(+), 5 deletions(-)
 create mode 100644 tests/EvoSC.Common.Tests/Config/Mapping/TextColorTypeParserTests.cs

diff --git a/src/EvoSC.Common/Config/Mapping/TextColorTypeParser.cs b/src/EvoSC.Common/Config/Mapping/TextColorTypeParser.cs
index b504bf7fd..0cd50ff4b 100644
--- a/src/EvoSC.Common/Config/Mapping/TextColorTypeParser.cs
+++ b/src/EvoSC.Common/Config/Mapping/TextColorTypeParser.cs
@@ -13,13 +13,21 @@ public bool TryParse(string? value, Type t, out object? result)
             return false;
         }
 
-        var r = Convert.FromHexString("0"+ value[0]).First();
-        var g = Convert.FromHexString("0"+ value[1]).First();
-        var b = Convert.FromHexString("0"+ value[2]).First();
+        try
+        {
+            var r = Convert.FromHexString("0" + value[0]).First();
+            var g = Convert.FromHexString("0" + value[1]).First();
+            var b = Convert.FromHexString("0" + value[2]).First();
 
-        result = new TextColor(r, g, b);
+            result = new TextColor(r, g, b);
 
-        return true;
+            return true;
+        }
+        catch (FormatException ex)
+        {
+            result = null;
+            return false;
+        }
     }
 
     public string? ToRawString(object? value)
diff --git a/tests/EvoSC.Common.Tests/Config/Mapping/TextColorTypeParserTests.cs b/tests/EvoSC.Common.Tests/Config/Mapping/TextColorTypeParserTests.cs
new file mode 100644
index 000000000..1c071bf95
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Config/Mapping/TextColorTypeParserTests.cs
@@ -0,0 +1,62 @@
+using System;
+using EvoSC.Common.Config.Mapping;
+using EvoSC.Common.Util.TextFormatting;
+using Xunit;
+
+namespace EvoSC.Common.Tests.Config.Mapping;
+
+public class TextColorTypeParserTests
+{
+    [Theory]
+    [InlineData("123", true, new byte[]{1,2,3})]
+    [InlineData("000", true, new byte[]{0,0,0})]
+    [InlineData("fff", true, new byte[]{0xf,0xf,0xf})]
+    [InlineData("", false, new byte[]{})]
+    [InlineData("00x", false, new byte[]{})]
+    [InlineData("abcaaaaaaaa", false, new byte[]{})]
+    [InlineData("1ab", true, new byte[]{0x1, 0xa, 0xb})]
+    public void Text_Color_Parsed(string value, bool shouldBeParsed, byte[] expected)
+    {
+        var colorParser = new TextColorTypeParser();
+
+        bool parsed = colorParser.TryParse(value, null, out var result);
+
+        if (shouldBeParsed)
+        {
+            Assert.NotNull(result);
+            Assert.True(parsed);
+            Assert.Equal(new TextColor(expected[0], expected[1], expected[2]).ToString(), result.ToString());
+        }
+        else
+        {
+            Assert.False(parsed);
+        }
+    }
+
+    [Fact]
+    public void Supported_Types_Is_TextColor()
+    {
+        var colorParser = new TextColorTypeParser();
+        
+        Assert.Equal(new Type[]{typeof(TextColor)}, colorParser.SupportedTypes);
+    }
+
+    [Theory]
+    [InlineData(new byte[]{1,2,3}, "123")]
+    [InlineData(null, "")]
+    public void RawString_Outputs_Correct_Config_Format(byte[]? color, string? expected)
+    {
+        TextColor textColor = null;
+
+        if (color != null)
+        {
+            textColor = new TextColor(color[0], color[1], color[2]);
+        }
+        
+        var colorParser = new TextColorTypeParser();
+
+        var value = colorParser.ToRawString(textColor);
+        
+        Assert.Equal(expected, value);
+    }
+}

From d0eb7b61e52f03a0de2686fb1847c6577b19588e Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Wed, 5 Jul 2023 10:43:08 +0200
Subject: [PATCH 09/22] text color mapper tests

---
 .../Mapping/TextColorTypeParserTests.cs       | 44 +++++++++++++++++++
 .../TestFiles/ConfigTests.cs                  | 10 -----
 2 files changed, 44 insertions(+), 10 deletions(-)
 delete mode 100644 tests/EvoSC.Common.Tests/TestFiles/ConfigTests.cs

diff --git a/tests/EvoSC.Common.Tests/Config/Mapping/TextColorTypeParserTests.cs b/tests/EvoSC.Common.Tests/Config/Mapping/TextColorTypeParserTests.cs
index 1c071bf95..d08485f5e 100644
--- a/tests/EvoSC.Common.Tests/Config/Mapping/TextColorTypeParserTests.cs
+++ b/tests/EvoSC.Common.Tests/Config/Mapping/TextColorTypeParserTests.cs
@@ -1,6 +1,9 @@
 using System;
 using EvoSC.Common.Config.Mapping;
+using EvoSC.Common.Config.Mapping.Toml;
 using EvoSC.Common.Util.TextFormatting;
+using Tomlet.Exceptions;
+using Tomlet.Models;
 using Xunit;
 
 namespace EvoSC.Common.Tests.Config.Mapping;
@@ -59,4 +62,45 @@ public void RawString_Outputs_Correct_Config_Format(byte[]? color, string? expec
         
         Assert.Equal(expected, value);
     }
+
+    [Theory]
+    [InlineData("123", new byte[]{1, 2, 3})]
+    [InlineData("000", new byte[]{0, 0, 0})]
+    [InlineData("fff", new byte[]{0xf, 0xf, 0xf})]
+    public void Mapper_Serializes_Color_Correctly(string expected, byte[] color)
+    {
+        var mapper = new TextColorTomlMapper();
+
+        var value = mapper.Serialize(new TextColor(color[0], color[1], color[2]));
+
+        Assert.Equal(expected, value.StringValue);
+    }
+
+    [Theory]
+    [InlineData("123", new byte[]{1, 2, 3})]
+    [InlineData("000", new byte[]{0, 0, 0})]
+    [InlineData("fff", new byte[]{0xf, 0xf, 0xf})]
+    public void Mapper_Deserializes_Color_Correctly(string value, byte[] color)
+    {
+        var mapper = new TextColorTomlMapper();
+        var tomlValue = new TomlString(value);
+        var r = Convert.ToHexString(color, 0, 1)[1..];
+        var g = Convert.ToHexString(color, 1, 1)[1..];
+        var b = Convert.ToHexString(color, 2, 1)[1..];
+
+        var textColor = mapper.Deserialize(tomlValue);
+
+        var expected = $"${r}{g}{b}".ToLower();
+        
+        Assert.Equal(expected, textColor.ToString());
+    }
+
+    [Fact]
+    public void Mapper_Deserializer_Throws_On_Wrong_Toml_Value_Type()
+    {
+        var mapper = new TextColorTomlMapper();
+        var tomlValue = new TomlLong(123);
+
+        Assert.Throws<TomlTypeMismatchException>(() => mapper.Deserialize(tomlValue));
+    }
 }
diff --git a/tests/EvoSC.Common.Tests/TestFiles/ConfigTests.cs b/tests/EvoSC.Common.Tests/TestFiles/ConfigTests.cs
deleted file mode 100644
index 9db1bbfa2..000000000
--- a/tests/EvoSC.Common.Tests/TestFiles/ConfigTests.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using Config.Net;
-using EvoSC.Common.Config.Models;
-using EvoSC.Common.Config.Stores;
-using Xunit;
-
-namespace EvoSC.Common.Tests.TestFiles;
-
-public class ConfigTests
-{
-}

From bfcdd7616bebe5057a49a757fe9808165248567b Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Wed, 5 Jul 2023 11:16:14 +0200
Subject: [PATCH 10/22] toml config store tests

---
 .../Config/Stores/TomlConfigStore.cs          |   7 -
 .../Config/Stores/TomlConfigStoreTests.cs     | 123 ++++++++++++++++++
 .../EvoSC.Common.Tests.csproj                 |   4 +
 .../TestFiles/Config/BasicConfig/main.toml    |  55 +++++++-
 4 files changed, 178 insertions(+), 11 deletions(-)
 create mode 100644 tests/EvoSC.Common.Tests/Config/Stores/TomlConfigStoreTests.cs

diff --git a/src/EvoSC.Common/Config/Stores/TomlConfigStore.cs b/src/EvoSC.Common/Config/Stores/TomlConfigStore.cs
index c34070ea9..b8973c62c 100644
--- a/src/EvoSC.Common/Config/Stores/TomlConfigStore.cs
+++ b/src/EvoSC.Common/Config/Stores/TomlConfigStore.cs
@@ -93,13 +93,6 @@ public void Dispose()
         // do nothing because the document lives for the entire application and is disposed on shutdown
     }
 
-    private string GetArrayValue(string key)
-    {
-        var value = _document.GetValue(key) as TomlArray;
-
-        return string.Join(" ", value.Select(v => v.StringValue));
-    }
-    
     public string? Read(string key)
     {
         var lastDotIndex = key.LastIndexOf(".", StringComparison.Ordinal);
diff --git a/tests/EvoSC.Common.Tests/Config/Stores/TomlConfigStoreTests.cs b/tests/EvoSC.Common.Tests/Config/Stores/TomlConfigStoreTests.cs
new file mode 100644
index 000000000..77bc7e839
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Config/Stores/TomlConfigStoreTests.cs
@@ -0,0 +1,123 @@
+using System;
+using System.IO;
+using Config.Net;
+using EvoSC.Common.Config.Mapping;
+using EvoSC.Common.Config.Models;
+using EvoSC.Common.Config.Stores;
+using Tomlet.Exceptions;
+using Xunit;
+
+namespace EvoSC.Common.Tests.Config.Stores;
+
+public class TomlConfigStoreTests
+{
+    private static string ConfigFile = "TestFiles/Config/BasicConfig/main.toml";
+
+    private TomlConfigStore<IEvoScBaseConfig> GetStore() => new TomlConfigStore<IEvoScBaseConfig>(ConfigFile);
+
+    [Fact]
+    public void Can_Read()
+    {
+        var store = GetStore();
+        
+        Assert.True(store.CanRead);
+    }
+    
+    [Fact]
+    public void Cant_Write()
+    {
+        var store = GetStore();
+        
+        Assert.False(store.CanWrite);
+        Assert.Throws<NotSupportedException>(() => store.Write("test", "test"));
+    }
+
+    [Theory]
+    [InlineData("Database.type", "PostgreSql")]
+    [InlineData("Database.port", "1234")]
+    [InlineData("Logging.useJson", "false")]
+    [InlineData("Theme.Chat.primaryTextColor", "123")]
+    [InlineData("Modules.moduleDirectories", "mymodules")]
+    [InlineData("Modules.disabledModules", "mymodule mymodule2")]
+    [InlineData("Modules.disabledModules[0]", "mymodule")]
+    [InlineData("Modules.disabledModules[1]", "mymodule2")]
+    public void Reads_Value_Correctly(string key, string? expected)
+    {
+        var store = GetStore();
+
+        var value = store.Read(key);
+        
+        Assert.Equal(expected, value);
+    }
+
+    [Fact]
+    public void Invalid_Key_Throws_Exception()
+    {
+        var store = GetStore();
+
+        Assert.Throws<TomlNoSuchValueException>(() => store.Read("does.not.exist"));
+    }
+
+    [Fact]
+    public void Config_File_Is_Created_If_Nonexistent()
+    {
+        var path = "TestFiles/Config/auto_created.toml";
+        var store = new TomlConfigStore<IEvoScBaseConfig>(path);
+
+        var fileExists = File.Exists(path);
+        
+        Assert.True(fileExists);
+    }
+
+    [Fact]
+    public void Config_Directory_Is_Created_If_Noneexistent()
+    {
+        var path = "TestFiles/Config/AutoCreated";
+        var store = new TomlConfigStore<IEvoScBaseConfig>(path + "/config.toml");
+
+        var dirExists = Directory.Exists(path);
+        
+        Assert.True(dirExists);
+    }
+
+    [Fact]
+    public void EvoSc_Config_Parsed_With_Store()
+    {
+        var config = new ConfigurationBuilder<IEvoScBaseConfig>()
+            .UseConfigStore(new TomlConfigStore<IEvoScBaseConfig>(ConfigFile))
+            .UseTypeParser(new TextColorTypeParser())
+            .Build();
+        
+        Assert.Equal(IDatabaseConfig.DatabaseType.PostgreSql, config.Database.Type);
+        Assert.Equal("123.123.123.123", config.Database.Host);
+        Assert.Equal(1234, config.Database.Port);
+        Assert.Equal("testdb", config.Database.Name);
+        Assert.Equal("testdbname", config.Database.Username);
+        Assert.Equal("testdbpassword", config.Database.Password);
+        Assert.Equal("testprefix", config.Database.TablePrefix);
+        
+        Assert.Equal("debug", config.Logging.LogLevel);
+        Assert.False(config.Logging.UseJson);
+        
+        Assert.Equal("123.123.123.123", config.Server.Host);
+        Assert.Equal(1234, config.Server.Port);
+        Assert.Equal("TestAdmin", config.Server.Username);
+        Assert.Equal("TestPassword", config.Server.Password);
+        Assert.True(config.Server.RetryConnection);
+        
+        Assert.Equal("my/server/maps", config.Path.Maps);
+        
+        Assert.Equal("$123", config.Theme.Chat.PrimaryColor.ToString());
+        Assert.Equal("$567", config.Theme.Chat.SecondaryColor.ToString());
+        Assert.Equal("$89a", config.Theme.Chat.InfoColor.ToString());
+        Assert.Equal("$bcd", config.Theme.Chat.ErrorColor.ToString());
+        Assert.Equal("$ef0", config.Theme.Chat.WarningColor.ToString());
+        Assert.Equal("$123", config.Theme.Chat.SuccessColor.ToString());
+        
+        Assert.Equal("no", config.Locale.DefaultLanguage);
+        
+        Assert.False(config.Modules.RequireSignatureVerification);
+        Assert.Equal(new []{"mymodules"}, config.Modules.ModuleDirectories);
+        Assert.Equal(new []{"mymodule", "mymodule2"}, config.Modules.DisabledModules);
+    }
+}
diff --git a/tests/EvoSC.Common.Tests/EvoSC.Common.Tests.csproj b/tests/EvoSC.Common.Tests/EvoSC.Common.Tests.csproj
index fcfbd4720..7a3eda757 100644
--- a/tests/EvoSC.Common.Tests/EvoSC.Common.Tests.csproj
+++ b/tests/EvoSC.Common.Tests/EvoSC.Common.Tests.csproj
@@ -59,4 +59,8 @@
       </EmbeddedResource>
     </ItemGroup>
 
+    <ItemGroup>
+      <Folder Include="Config\Stores\TestFiles\" />
+    </ItemGroup>
+
 </Project>
diff --git a/tests/EvoSC.Common.Tests/TestFiles/Config/BasicConfig/main.toml b/tests/EvoSC.Common.Tests/TestFiles/Config/BasicConfig/main.toml
index 6956fab22..1c7b74c73 100644
--- a/tests/EvoSC.Common.Tests/TestFiles/Config/BasicConfig/main.toml
+++ b/tests/EvoSC.Common.Tests/TestFiles/Config/BasicConfig/main.toml
@@ -1,3 +1,19 @@
+[Database]
+# The type of database to use. Available types: PostgreSql, MySql, SQLite
+type = "PostgreSql"
+# Address to the database
+host = "123.123.123.123"
+# Port of the database
+port = 1234
+# The name of the database
+name = "testdb"
+# Name of the user to access the database
+username = "testdbname"
+# Password of the user to access the database
+password = "testdbpassword"
+# A string prefix to add to all table names
+tablePrefix = "testprefix"
+
 [Logging]
 # Possible values lowest to highest verbosity: none, critical, error, warning, information, debug, trace
 logLevel = "debug"
@@ -10,8 +26,39 @@ host = "123.123.123.123"
 # Port that the XMLRPC is listening to
 port = 1234
 # Username of the super admin account
-username = "My Admin "
+username = "TestAdmin"
 # Password of the super admin account
-password = " My Admin"
-# If enabled, the client will try to reconnect with the server every 1 second until a connection is established.
-retryConnection = false
\ No newline at end of file
+password = "TestPassword"
+# If enabled, the client will try to reconnect with the server every 1 second until a connection is established
+retryConnection = true
+
+[Path]
+# Path to the maps folder
+maps = "my/server/maps"
+
+[Theme]
+[Theme.Chat]
+# The primary text color to use.
+primaryTextColor = "123"
+# The secondary text color to use.
+secondaryTextColor = "567"
+# The color to use for info messages.
+infoTextColor = "89a"
+# The color to use for error messages.
+errorTextColor = "bcd"
+# The color to use for warning messages.
+warningTextColor = "ef0"
+# The color to use for success messages.
+successTextColor = "123"
+
+[Locale]
+# The default display language of the controller. Must be a "language tag" as found here: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-lcid/a9eac961-e77d-41a6-90a5-ce1a8b0cdb9c
+defaultLanguage = "no"
+
+[Modules]
+# Signature verification of module's files. If enabled and verification fails, the module will not load.
+requireSignatureVerification = false
+# Directories to scan for external modules.
+moduleDirectories = [ "mymodules", ]
+# Modules that will not load on startup. Note that if a module depend on a disabled module, it will load anyways.
+disabledModules = [ "mymodule", "mymodule2" ]

From 1ec175bf82925746fc5edbe0e9e38282cd6a46cd Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Wed, 5 Jul 2023 11:26:42 +0200
Subject: [PATCH 11/22] base config store tests

---
 .../Stores/EvoScBaseConfigStoreTests.cs       | 105 ++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 tests/EvoSC.Common.Tests/Config/Stores/EvoScBaseConfigStoreTests.cs

diff --git a/tests/EvoSC.Common.Tests/Config/Stores/EvoScBaseConfigStoreTests.cs b/tests/EvoSC.Common.Tests/Config/Stores/EvoScBaseConfigStoreTests.cs
new file mode 100644
index 000000000..864852bb6
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Config/Stores/EvoScBaseConfigStoreTests.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using EvoSC.Common.Config;
+using EvoSC.Common.Config.Models;
+using Xunit;
+
+namespace EvoSC.Common.Tests.Config.Stores;
+
+public class EvoScBaseConfigStoreTests
+{
+    private static string ConfigFile = "TestFiles/Config/BasicConfig/main.toml";
+    
+    [Fact]
+    public void Environment_Variables_Overrides_FileConfig_Simple_Option()
+    {
+        Environment.SetEnvironmentVariable("EVOSC_DATABASE_TYPE", "MySql");
+        var config = Configuration.GetBaseConfig(ConfigFile, new Dictionary<string, string>());
+
+        Assert.Equal(IDatabaseConfig.DatabaseType.MySql, config.Database.Type);
+    }
+
+    [Fact]
+    public void Environment_Variables_Overrides_FileConfig_Array_Option()
+    {
+        Environment.SetEnvironmentVariable("EVOSC_MODULES_MODULEDIRECTORIES", "dir1 dir2");
+        var config = Configuration.GetBaseConfig(ConfigFile, new Dictionary<string, string>());
+
+        Assert.Equal(new []{"dir1", "dir2"}, config.Modules.ModuleDirectories);
+    }
+
+    [Fact]
+    public void Environment_Variables_Overrides_FileConfig_Boolean_Option()
+    {
+        Environment.SetEnvironmentVariable("EVOSC_MODULES_REQUIRESIGNATUREVERIFICATION", "true");
+        var config = Configuration.GetBaseConfig(ConfigFile, new Dictionary<string, string>());
+
+        Assert.True(config.Modules.RequireSignatureVerification);
+    }
+
+    [Fact]
+    public void Environment_Variables_Overrides_FileConfig_CustomType_Option()
+    {
+        Environment.SetEnvironmentVariable("EVOSC_THEME_CHAT_PRIMARYTEXTCOLOR", "745");
+        var config = Configuration.GetBaseConfig(ConfigFile, new Dictionary<string, string>());
+
+        Assert.Equal("$745", config.Theme.Chat.PrimaryColor.ToString());
+    }
+    
+    
+    [Fact]
+    public void CliOption_Overrides_FileConfig_Simple_Option()
+    {
+        var config = Configuration.GetBaseConfig(ConfigFile, new Dictionary<string, string>()
+        {
+            {"Database.type", "MySql"}
+        });
+
+        Assert.Equal(IDatabaseConfig.DatabaseType.MySql, config.Database.Type);
+    }
+
+    [Fact]
+    public void CliOption_Variables_Overrides_FileConfig_Array_Option()
+    {
+        var config = Configuration.GetBaseConfig(ConfigFile, new Dictionary<string, string>()
+        {
+            {"Modules.moduleDirectories", "dir1 dir2"}
+        });
+
+        Assert.Equal(new []{"dir1", "dir2"}, config.Modules.ModuleDirectories);
+    }
+
+    [Fact]
+    public void CliOption_Variables_Overrides_FileConfig_Boolean_Option()
+    {
+        var config = Configuration.GetBaseConfig(ConfigFile, new Dictionary<string, string>()
+        {
+            {"Modules.requireSignatureVerification", "true"}
+        });
+
+        Assert.True(config.Modules.RequireSignatureVerification);
+    }
+
+    [Fact]
+    public void CliOption_Variables_Overrides_FileConfig_CustomType_Option()
+    {
+        var config = Configuration.GetBaseConfig(ConfigFile, new Dictionary<string, string>()
+        {
+            {"Theme.Chat.primaryTextColor", "745"}
+        });
+
+        Assert.Equal("$745", config.Theme.Chat.PrimaryColor.ToString());
+    }
+
+    [Fact]
+    public void CliOption_Overrides_Environment_Variable()
+    {
+        Environment.SetEnvironmentVariable("EVOSC_DATABASE_TYPE", "MySql");
+        var config = Configuration.GetBaseConfig(ConfigFile, new Dictionary<string, string>()
+        {
+            {"Database.type", "SQLite"}
+        });
+        
+        Assert.Equal(IDatabaseConfig.DatabaseType.SQLite, config.Database.Type);
+    }
+}

From 1cb052e89bdcd380fd4e1870fd770b7e47ef1f96 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Wed, 5 Jul 2023 11:34:11 +0200
Subject: [PATCH 12/22] more tests

---
 .../Config/Stores/EvoSCBaseConfigStore.cs      |  2 +-
 .../Config/Stores/EvoScBaseConfigStoreTests.cs | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs b/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
index 8786ac7f9..f5e48b7dd 100644
--- a/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
+++ b/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
@@ -39,7 +39,7 @@ public void Dispose()
 
     public void Write(string key, string? value)
     {
-        throw new NotImplementedException();
+        throw new NotSupportedException();
     }
 
     public bool CanRead => true;
diff --git a/tests/EvoSC.Common.Tests/Config/Stores/EvoScBaseConfigStoreTests.cs b/tests/EvoSC.Common.Tests/Config/Stores/EvoScBaseConfigStoreTests.cs
index 864852bb6..e15516b09 100644
--- a/tests/EvoSC.Common.Tests/Config/Stores/EvoScBaseConfigStoreTests.cs
+++ b/tests/EvoSC.Common.Tests/Config/Stores/EvoScBaseConfigStoreTests.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using EvoSC.Common.Config;
 using EvoSC.Common.Config.Models;
+using EvoSC.Common.Config.Stores;
 using Xunit;
 
 namespace EvoSC.Common.Tests.Config.Stores;
@@ -9,7 +10,24 @@ namespace EvoSC.Common.Tests.Config.Stores;
 public class EvoScBaseConfigStoreTests
 {
     private static string ConfigFile = "TestFiles/Config/BasicConfig/main.toml";
+
+    [Fact]
+    public void Can_Read()
+    {
+        var store = new EvoScBaseConfigStore(ConfigFile, new Dictionary<string, string>());
+        
+        Assert.True(store.CanRead);
+    }
     
+    [Fact]
+    public void Cant_Write()
+    {
+        var store = new EvoScBaseConfigStore(ConfigFile, new Dictionary<string, string>());
+        
+        Assert.False(store.CanWrite);
+        Assert.Throws<NotSupportedException>(() => store.Write("test", "test"));
+    }
+
     [Fact]
     public void Environment_Variables_Overrides_FileConfig_Simple_Option()
     {

From 6553b83a929ac5570742686c5b7840ee55b82a78 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Wed, 5 Jul 2023 13:02:28 +0200
Subject: [PATCH 13/22] db config store tests

---
 .../Config/Stores/DatabaseStoreTests.cs       | 92 +++++++++++++++++++
 .../Stores/TestModels/ISimpleDbConfig.cs      | 15 +++
 .../Stores/TestModels/ISimpleSubOption.cs     |  6 ++
 3 files changed, 113 insertions(+)
 create mode 100644 tests/EvoSC.Common.Tests/Config/Stores/DatabaseStoreTests.cs
 create mode 100644 tests/EvoSC.Common.Tests/Config/Stores/TestModels/ISimpleDbConfig.cs
 create mode 100644 tests/EvoSC.Common.Tests/Config/Stores/TestModels/ISimpleSubOption.cs

diff --git a/tests/EvoSC.Common.Tests/Config/Stores/DatabaseStoreTests.cs b/tests/EvoSC.Common.Tests/Config/Stores/DatabaseStoreTests.cs
new file mode 100644
index 000000000..c1347e9bc
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Config/Stores/DatabaseStoreTests.cs
@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using EvoSC.Common.Config.Stores;
+using EvoSC.Common.Database.Models.Config;
+using EvoSC.Common.Interfaces.Database.Repository;
+using EvoSC.Common.Tests.Config.Stores.TestModels;
+using Moq;
+using Xunit;
+
+namespace EvoSC.Common.Tests.Config.Stores;
+
+public class DatabaseStoreTests
+{
+    [Fact]
+    public void Can_Read_And_Write()
+    {
+        var repo = new Mock<IConfigStoreRepository>();
+        var store = new DatabaseStore("", typeof(ISimpleDbConfig), repo.Object);
+        
+        Assert.True(store.CanRead);
+        Assert.True(store.CanWrite);
+    }
+    
+    [Fact]
+    public void Default_Settings_Created()
+    {
+        var repo = new Mock<IConfigStoreRepository>();
+        var store = new DatabaseStore("", typeof(ISimpleDbConfig), repo.Object);
+
+        store.SetupDefaultSettingsAsync();
+
+        repo.Verify(c => c
+                .AddConfigOptionAsync(It.IsAny<DbConfigOption>())
+            , Times.Exactly(3));
+    }
+
+    [Fact]
+    public void Option_Is_Read_From_Store()
+    {
+        var repo = new Mock<IConfigStoreRepository>();
+        repo.Setup(c => c.GetConfigOptionsByKeyAsync("MyModule.SimpleDbConfig.MyOption"))
+            .Returns(() => Task.FromResult(new DbConfigOption
+            {
+                Key = "MyModule.SimpleDbConfig.MyOption",
+                Value = "MyOptionValue"
+            }));
+        
+        var store = new DatabaseStore("MyModule", typeof(ISimpleDbConfig), repo.Object);
+
+        var value = store.Read("MyOption");
+        
+        Assert.Equal("MyOptionValue", value);
+    }
+
+    [Fact]
+    public void Option_Not_Found_In_Store_Throws_Exception()
+    {
+        var repo = new Mock<IConfigStoreRepository>();
+        var store = new DatabaseStore("MyModule", typeof(ISimpleDbConfig), repo.Object);
+
+        Assert.Throws<KeyNotFoundException>(() => store.Read("Non.Existent.Key"));
+    }
+
+    [Fact]
+    public void Existing_Key_Value_Is_Written_To_Store()
+    {
+        var repo = new Mock<IConfigStoreRepository>();
+        repo.Setup(c => c.GetConfigOptionsByKeyAsync("MyModule.SimpleDbConfig.MyOption"))
+            .Returns(() => Task.FromResult(new DbConfigOption
+            {
+                Key = "MyModule.SimpleDbConfig.MyOption", Value = "MyOptionValue"
+            }));
+
+        var store = new DatabaseStore("MyModule", typeof(ISimpleDbConfig), repo.Object);
+        
+        store.Write("MyOption", "Test");
+
+        repo.Verify(c => c.UpdateConfigOptionAsync(It.IsAny<DbConfigOption>()));
+    }
+
+    [Fact]
+    public void Nonexistent_Key_Value_Is_Written_To_Store()
+    {
+        var repo = new Mock<IConfigStoreRepository>();
+        
+        var store = new DatabaseStore("MyModule", typeof(ISimpleDbConfig), repo.Object);
+        
+        store.Write("MyOption", "Test");
+
+        repo.Verify(c => c.AddConfigOptionAsync(It.IsAny<DbConfigOption>()));
+    }
+}
diff --git a/tests/EvoSC.Common.Tests/Config/Stores/TestModels/ISimpleDbConfig.cs b/tests/EvoSC.Common.Tests/Config/Stores/TestModels/ISimpleDbConfig.cs
new file mode 100644
index 000000000..0caedbfe8
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Config/Stores/TestModels/ISimpleDbConfig.cs
@@ -0,0 +1,15 @@
+using Config.Net;
+
+namespace EvoSC.Common.Tests.Config.Stores.TestModels;
+
+public interface ISimpleDbConfig
+{
+    [Option(DefaultValue = "Test")]
+    public string MyOption { get; set; }
+    
+    [Option(Alias = "myAlias")]
+    public string MyOption2 { get; set; }
+    
+    [Option]
+    public ISimpleSubOption MySubOption { get; set; }
+}
diff --git a/tests/EvoSC.Common.Tests/Config/Stores/TestModels/ISimpleSubOption.cs b/tests/EvoSC.Common.Tests/Config/Stores/TestModels/ISimpleSubOption.cs
new file mode 100644
index 000000000..13491583c
--- /dev/null
+++ b/tests/EvoSC.Common.Tests/Config/Stores/TestModels/ISimpleSubOption.cs
@@ -0,0 +1,6 @@
+namespace EvoSC.Common.Tests.Config.Stores.TestModels;
+
+public interface ISimpleSubOption
+{
+    public int MySubOption { get; set; }
+}

From 3f3609a4158e0492b77db656bcb8b6091385c7e4 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Wed, 5 Jul 2023 13:32:47 +0200
Subject: [PATCH 14/22] sonarcloud fixes

---
 src/EvoSC.CLI/CliManager.cs                   |   2 -
 src/EvoSC.CLI/CliStartup.cs                   |  16 +-
 src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs   |   1 -
 src/EvoSC.CLI/Models/CliEvoScConfig.cs        |   4 +-
 .../Application/StartupPipeline.cs            |  16 +-
 src/EvoSC.Common/Config/Configuration.cs      |   2 -
 .../Config/Mapping/Toml/ConfigMapper.cs       |   2 +-
 .../Config/Stores/EvoSCBaseConfigStore.cs     |   2 +-
 .../Interfaces/IStartupPipeline.cs            |  13 +-
 src/EvoSC/Application.cs                      | 155 +-----------------
 src/EvoSC/ApplicationSetup.cs                 |  16 +-
 src/EvoSC/CliCommands/RunCommand.cs           |   1 -
 .../Application/StartupPipelineTests.cs       |   2 +-
 13 files changed, 31 insertions(+), 201 deletions(-)

diff --git a/src/EvoSC.CLI/CliManager.cs b/src/EvoSC.CLI/CliManager.cs
index 182302040..47f24d649 100644
--- a/src/EvoSC.CLI/CliManager.cs
+++ b/src/EvoSC.CLI/CliManager.cs
@@ -13,7 +13,6 @@
 using EvoSC.Common.Util;
 using EvoSC.Common.Util.EnumIdentifier;
 using Microsoft.Extensions.DependencyInjection;
-using Org.BouncyCastle.Asn1.X509.Qualified;
 
 namespace EvoSC.CLI;
 
@@ -196,7 +195,6 @@ await startupPipeline.ExecuteAsync(command.RequiredFeatures
 
     public Task<int> ExecuteAsync(string[] args)
     {
-        // return _rootCommand.InvokeAsync(args);
         return _cliParser.InvokeAsync(args);
     }
 }
diff --git a/src/EvoSC.CLI/CliStartup.cs b/src/EvoSC.CLI/CliStartup.cs
index b8aa3a508..6fb8d4322 100644
--- a/src/EvoSC.CLI/CliStartup.cs
+++ b/src/EvoSC.CLI/CliStartup.cs
@@ -1,6 +1,4 @@
-using System.Reflection.PortableExecutable;
-using EvoSC.Commands;
-using EvoSC.Commands.Interfaces;
+using EvoSC.Commands;
 using EvoSC.Common.Application;
 using EvoSC.Common.Config.Models;
 using EvoSC.Common.Controllers;
@@ -8,8 +6,6 @@
 using EvoSC.Common.Database.Extensions;
 using EvoSC.Common.Events;
 using EvoSC.Common.Interfaces;
-using EvoSC.Common.Interfaces.Controllers;
-using EvoSC.Common.Interfaces.Middleware;
 using EvoSC.Common.Interfaces.Services;
 using EvoSC.Common.Logging;
 using EvoSC.Common.Middleware;
@@ -19,8 +15,6 @@
 using EvoSC.Manialinks;
 using EvoSC.Manialinks.Interfaces;
 using EvoSC.Modules.Extensions;
-using EvoSC.Modules.Interfaces;
-using EvoSC.Modules.Util;
 using SimpleInjector;
 
 namespace EvoSC.CLI;
@@ -94,16 +88,16 @@ public static void SetupBasePipeline(this IStartupPipeline pipeline, IEvoScBaseC
                     .GetInstance<IManialinkInteractionHandler>()
                 , "ActionInitializeEventManager", "ActionInitializePlayerCache")
 
-            .ActionAsync("InitializeGbxRemoteConnection", SetupGbxRemoteConnection,
+            .AsyncAction("InitializeGbxRemoteConnection", SetupGbxRemoteConnectionAsync,
                 "ActionInitializeEventManager",
                 "ActionInitializePlayerCache",
                 "ActionInitializeManialinkInteractionHandler",
                 "GbxRemoteClient")
 
-            .ActionAsync("ActionInitializeTemplates", InitializeTemplates, "Manialinks");
+            .AsyncAction("ActionInitializeTemplates", InitializeTemplatesAsync, "Manialinks");
     }
     
-    private static async Task InitializeTemplates(ServicesBuilder s)
+    private static async Task InitializeTemplatesAsync(ServicesBuilder s)
     {
         var maniaLinks = s.GetInstance<IManialinkManager>();
         await maniaLinks.PreprocessAllAsync();
@@ -118,7 +112,7 @@ private static void MigrateDatabase(ServicesBuilder s)
         manager.MigrateFromAssembly(typeof(MigrationManager).Assembly);
     }
 
-    private static async Task SetupGbxRemoteConnection(ServicesBuilder s)
+    private static async Task SetupGbxRemoteConnectionAsync(ServicesBuilder s)
     {
         var serverClient = s.GetInstance<IServerClient>();
         s.GetInstance<IServerCallbackHandler>();
diff --git a/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs b/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs
index 6337d034d..7b966762c 100644
--- a/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs
+++ b/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs
@@ -1,6 +1,5 @@
 using System.CommandLine;
 using System.Reflection;
-using EvoSC.CLI.Attributes;
 using EvoSC.Common.Application;
 
 namespace EvoSC.CLI.Interfaces;
diff --git a/src/EvoSC.CLI/Models/CliEvoScConfig.cs b/src/EvoSC.CLI/Models/CliEvoScConfig.cs
index 32b7d1eec..e6deea629 100644
--- a/src/EvoSC.CLI/Models/CliEvoScConfig.cs
+++ b/src/EvoSC.CLI/Models/CliEvoScConfig.cs
@@ -1,6 +1,4 @@
-using System.CommandLine.Binding;
-
-namespace EvoSC.CLI.Models;
+namespace EvoSC.CLI.Models;
 
 public class CliEvoScConfig
 {
diff --git a/src/EvoSC.Common/Application/StartupPipeline.cs b/src/EvoSC.Common/Application/StartupPipeline.cs
index 11d146286..c43fc3978 100644
--- a/src/EvoSC.Common/Application/StartupPipeline.cs
+++ b/src/EvoSC.Common/Application/StartupPipeline.cs
@@ -11,14 +11,12 @@ namespace EvoSC.Common.Application;
 
 public class StartupPipeline : IStartupPipeline
 {
-    private readonly IEvoScBaseConfig _config;
     private readonly ServicesBuilder _services;
     private readonly ILogger<StartupPipeline> _logger;
     private readonly Dictionary<string, IStartupComponent> _components = new();
     
     public StartupPipeline(IEvoScBaseConfig config)
     {
-        _config = config;
         _services = new ServicesBuilder();
 
         _logger = new Container().AddEvoScLogging(config.Logging).GetInstance<ILogger<StartupPipeline>>();
@@ -36,21 +34,21 @@ public IStartupPipeline Services(string name, Action<ServicesBuilder> servicesCo
         return this;
     }
 
-    public IStartupPipeline Action(string name, Action<ServicesBuilder> action, params string[] dependencies)
+    public IStartupPipeline Action(string name, Action<ServicesBuilder> actionFunc, params string[] dependencies)
     {
         _components[name] = new ActionStartupComponent
         {
-            Name = name, Dependencies = dependencies.ToList(), Action = action
+            Name = name, Dependencies = dependencies.ToList(), Action = actionFunc
         };
         
         return this;
     }
 
-    public IStartupPipeline ActionAsync(string name, Func<ServicesBuilder, Task> action, params string[] dependencies)
+    public IStartupPipeline AsyncAction(string name, Func<ServicesBuilder, Task> actionFunc, params string[] dependencies)
     {
         _components[name] = new AsyncActionStartupComponent
         {
-            Name = name, Dependencies = dependencies.ToList(), AsyncAction = action
+            Name = name, Dependencies = dependencies.ToList(), AsyncAction = actionFunc
         };
 
         return this;
@@ -74,7 +72,7 @@ private async Task ExecuteComponentAsync(IStartupComponent component)
         }
     }
     
-    private async Task ExecuteAsyncInternal(IEnumerable<string> components, List<string> dependencyPath)
+    private async Task ExecuteAsyncInternalAsync(IEnumerable<string> components, List<string> dependencyPath)
     {
         foreach (var name in components)
         {
@@ -90,7 +88,7 @@ private async Task ExecuteAsyncInternal(IEnumerable<string> components, List<str
                     var newPath = new List<string>();
                     newPath.AddRange(dependencyPath);
                     newPath.Add(name);
-                    await ExecuteAsyncInternal(component.Dependencies.ToArray(), newPath);
+                    await ExecuteAsyncInternalAsync(component.Dependencies.ToArray(), newPath);
                 }
 
                 await ExecuteComponentAsync(component);
@@ -104,7 +102,7 @@ private async Task ExecuteAsyncInternal(IEnumerable<string> components, List<str
     
     public Task ExecuteAsync(params string[] components)
     {
-        return ExecuteAsyncInternal(components, Array.Empty<string>().ToList());
+        return ExecuteAsyncInternalAsync(components, Array.Empty<string>().ToList());
     }
 
     public async Task ExecuteAllAsync()
diff --git a/src/EvoSC.Common/Config/Configuration.cs b/src/EvoSC.Common/Config/Configuration.cs
index 846872328..d2b198150 100644
--- a/src/EvoSC.Common/Config/Configuration.cs
+++ b/src/EvoSC.Common/Config/Configuration.cs
@@ -3,8 +3,6 @@
 using EvoSC.Common.Config.Stores;
 using EvoSC.Common.Config.Mapping;
 using EvoSC.Common.Config.Mapping.Toml;
-using EvoSC.Common.Interfaces.Config.Mapping;
-using SimpleInjector;
 
 namespace EvoSC.Common.Config;
 
diff --git a/src/EvoSC.Common/Config/Mapping/Toml/ConfigMapper.cs b/src/EvoSC.Common/Config/Mapping/Toml/ConfigMapper.cs
index cf880d341..db005754d 100644
--- a/src/EvoSC.Common/Config/Mapping/Toml/ConfigMapper.cs
+++ b/src/EvoSC.Common/Config/Mapping/Toml/ConfigMapper.cs
@@ -3,7 +3,7 @@
 
 namespace EvoSC.Common.Config.Mapping.Toml;
 
-public class ConfigMapper
+public static class ConfigMapper
 {
     public static void AddMapper<T>(ITomlTypeMapper<T> mapper) =>
         TomletMain.RegisterMapper(mapper.Serialize, mapper.Deserialize);
diff --git a/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs b/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
index f5e48b7dd..36fa7c63f 100644
--- a/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
+++ b/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
@@ -28,7 +28,7 @@ public void Dispose()
             return null;
         }
         
-        var enviName = $"EVOSC_{key.Replace(".", "_").ToUpper()}";
+        var enviName = $"EVOSC_{key.Replace(".", "_", StringComparison.Ordinal).ToUpper()}";
         var enviValue = Environment.GetEnvironmentVariable(enviName);
 
         _cliOptions.TryGetValue(key, out var cliValue);
diff --git a/src/EvoSC.Common/Interfaces/IStartupPipeline.cs b/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
index bcd96244f..63cdd1a02 100644
--- a/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
+++ b/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
@@ -1,5 +1,4 @@
 using EvoSC.Common.Application;
-using EvoSC.Common.Util;
 using EvoSC.Common.Util.EnumIdentifier;
 using SimpleInjector;
 
@@ -13,15 +12,15 @@ public interface IStartupPipeline
 
     public IStartupPipeline Services(Enum name, Action<ServicesBuilder> servicesConfig, params string[] dependencies) =>
         Services(name.GetIdentifier(), servicesConfig, dependencies);
-    public IStartupPipeline Action(string name, Action<ServicesBuilder> action, params string[] dependencies);
+    public IStartupPipeline Action(string name, Action<ServicesBuilder> actionFunc, params string[] dependencies);
 
-    public IStartupPipeline Action(Enum name, Action<ServicesBuilder> action, params string[] dependencies) =>
-        Action(name.GetIdentifier(), action, dependencies);
+    public IStartupPipeline Action(Enum name, Action<ServicesBuilder> actionFunc, params string[] dependencies) =>
+        Action(name.GetIdentifier(), actionFunc, dependencies);
     
-    public IStartupPipeline ActionAsync(string name, Func<ServicesBuilder, Task> action, params string[] dependencies);
+    public IStartupPipeline AsyncAction(string name, Func<ServicesBuilder, Task> actionFunc, params string[] dependencies);
 
-    public IStartupPipeline ActionAsync(Enum name, Func<ServicesBuilder, Task> action, params string[] dependencies) =>
-        ActionAsync(name.GetIdentifier(), action, dependencies);
+    public IStartupPipeline AsyncAction(Enum name, Func<ServicesBuilder, Task> actionFunc, params string[] dependencies) =>
+        AsyncAction(name.GetIdentifier(), actionFunc, dependencies);
 
     public Task ExecuteAsync(params string[] components);
     public Task ExecuteAllAsync();
diff --git a/src/EvoSC/Application.cs b/src/EvoSC/Application.cs
index 225828c0a..2e1fcdccb 100644
--- a/src/EvoSC/Application.cs
+++ b/src/EvoSC/Application.cs
@@ -1,29 +1,7 @@
-using System.Diagnostics;
-using EvoSC.CLI;
-using EvoSC.Commands;
-using EvoSC.Commands.Interfaces;
-using EvoSC.Common.Application;
-using EvoSC.Common.Config;
+using EvoSC.Common.Application;
 using EvoSC.Common.Config.Models;
-using EvoSC.Common.Controllers;
-using EvoSC.Common.Database;
-using EvoSC.Common.Database.Extensions;
-using EvoSC.Common.Events;
 using EvoSC.Common.Interfaces;
-using EvoSC.Common.Interfaces.Controllers;
-using EvoSC.Common.Interfaces.Middleware;
-using EvoSC.Common.Interfaces.Services;
-using EvoSC.Common.Logging;
-using EvoSC.Common.Middleware;
-using EvoSC.Common.Permissions;
-using EvoSC.Common.Remote;
-using EvoSC.Common.Services;
-using EvoSC.Manialinks;
-using EvoSC.Manialinks.Interfaces;
-using EvoSC.Modules.Extensions;
 using EvoSC.Modules.Interfaces;
-using EvoSC.Modules.Util;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using SimpleInjector;
 using SimpleInjector.Lifestyles;
@@ -33,7 +11,6 @@ namespace EvoSC;
 public sealed class Application : IEvoSCApplication, IDisposable
 {
     private readonly bool _isDebug;
-    private ILogger<Application> _logger;
 
     private readonly IEvoScBaseConfig _config;
 
@@ -67,8 +44,6 @@ private void ConfigureServiceContainer()
 
     public async Task RunAsync()
     {
-        // await SetupApplicationAsync();
-        
         StartupPipeline.SetupPipeline(_config);
         await StartupPipeline.ExecuteAllAsync();
 
@@ -92,134 +67,6 @@ public async Task ShutdownAsync()
         _runningToken.Cancel();
     }
 
-    /* public async Task ShutdownAsync()
-    {
-        var serverClient = _services.GetInstance<IServerClient>();
-        await serverClient.StopAsync(_runningToken.Token);
-        
-        // cancel the token to stop the application itself
-        _runningToken.Cancel();
-    }
-
-    private async Task SetupApplicationAsync()
-    {
-        var sw = new Stopwatch();
-        sw.Start();
-
-        SetupServices();
-        MigrateDatabase();
-        SetupControllerManager();
-        await SetupModulesAsync();
-        await StartBackgroundServicesAsync();
-        await EnableModulesAsync();
-        await InitializeTemplatesAsync();
-        
-        sw.Stop();
-        
-        _logger.LogDebug("Startup time: {Time}ms", sw.ElapsedMilliseconds);
-    }
-
-    private void SetupServices()
-    {
-        _services.AddEvoScLogging(_config.Logging);
-        
-        _services.AddEvoScMigrations();
-        _services.AddEvoScDatabase(_config.Database);
-        
-        _services.AddGbxRemoteClient();
-        _services.AddEvoScEvents();
-        _services.AddEvoScModules();
-        _services.AddEvoScControllers();
-        _services.AddEvoScCommonServices();
-        _services.AddEvoScChatCommands();
-        _services.AddEvoScMiddlewarePipelines();
-        _services.AddEvoScPermissions();
-        _services.AddEvoScManialinks();
-
-        _services.RegisterInstance<IEvoSCApplication>(this);
-        
-        _logger = _services.GetInstance<ILogger<Application>>();
-    }
-
-    private void MigrateDatabase()
-    {
-        using var scope = new Scope(_services);
-        var manager = scope.GetInstance<IMigrationManager>();
-        
-        // main migrations
-        manager.MigrateFromAssembly(typeof(MigrationManager).Assembly);
-        
-        // internal modules
-        manager.RunInternalModuleMigrations();
-    }
-    
-    private void SetupControllerManager()
-    {
-        var controllers = _services.GetInstance<IControllerManager>();
-        controllers.AddControllerActionRegistry(_services.GetInstance<IEventManager>());
-        controllers.AddControllerActionRegistry(_services.GetInstance<IChatCommandManager>());
-        controllers.AddControllerActionRegistry(_services.GetInstance<IManialinkActionManager>());
-        
-        var pipelineManager = _services.GetInstance<IActionPipelineManager>();
-        pipelineManager.UseEvoScCommands(_services);
-        pipelineManager.UseEvoScManialinks(_services);
-    }
-
-    private async Task SetupModulesAsync()
-    {
-        var modules = _services.GetInstance<IModuleManager>();
-        var config = _services.GetInstance<IEvoScBaseConfig>();
-
-        await modules.LoadInternalModulesAsync();
-
-        var dirs = config.Modules.ModuleDirectories;
-        var externalModules = new SortedModuleCollection<IExternalModuleInfo>();
-        foreach (var dir in dirs)
-        {
-            if (!Directory.Exists(dir))
-            {
-                continue;
-            }
-
-            ModuleDirectoryUtils.FindModulesFromDirectory(dir, externalModules);
-        }
-
-        externalModules.SetIgnoredDependencies(modules.LoadedModules.Select(m => m.ModuleInfo.Name));
-        await modules.LoadAsync(externalModules);
-    }
-
-    private async Task StartBackgroundServicesAsync()
-    {
-        _logger.LogDebug("Starting background services");
-
-        // initialize event manager before anything else
-        _services.GetInstance<IEventManager>();
-
-        // initialize player cache
-        _services.GetInstance<IPlayerCacheService>();
-        
-        // initialize manialink handler
-        _services.GetInstance<IManialinkInteractionHandler>();
-
-        // connect to the dedicated server and setup callbacks and chat router
-        var serverClient = _services.GetInstance<IServerClient>();
-        _services.GetInstance<IServerCallbackHandler>();
-        _services.GetInstance<IRemoteChatRouter>();
-        await serverClient.StartAsync(_runningToken.Token);
-    }
-    
-    private async Task EnableModulesAsync()
-    {
-        await _services.GetRequiredService<IManialinkManager>().AddDefaultTemplatesAsync();
-        await _services.GetRequiredService<IModuleManager>().EnableModulesAsync();
-    }
-    
-    private async Task InitializeTemplatesAsync()
-    {
-        var maniaLinks = _services.GetRequiredService<IManialinkManager>();
-        await maniaLinks.PreprocessAllAsync();
-    } */
-
     public void Dispose()
     {
         Services.Dispose();
diff --git a/src/EvoSC/ApplicationSetup.cs b/src/EvoSC/ApplicationSetup.cs
index df447ca52..94778cbaa 100644
--- a/src/EvoSC/ApplicationSetup.cs
+++ b/src/EvoSC/ApplicationSetup.cs
@@ -83,7 +83,7 @@ public static void SetupPipeline(this IStartupPipeline pipeline, IEvoScBaseConfi
 
             .Action("ActionSetupControllerManager", SetupControllerManager)
 
-            .ActionAsync("ActionSetupModules", SetupModules)
+            .AsyncAction("ActionSetupModules", SetupModulesAsync)
 
             .Action("ActionInitializeEventManager", s => s
                 .GetInstance<IEventManager>()
@@ -97,20 +97,20 @@ public static void SetupPipeline(this IStartupPipeline pipeline, IEvoScBaseConfi
                 .GetInstance<IManialinkInteractionHandler>()
             )
 
-            .ActionAsync("InitializeGbxRemoteConnection", SetupGbxRemoteConnection)
+            .AsyncAction("InitializeGbxRemoteConnection", SetupGbxRemoteConnectionAsync)
 
-            .ActionAsync("ActionEnableModules", EnableModules)
+            .AsyncAction("ActionEnableModules", EnableModulesAsync)
 
-            .ActionAsync("ActionInitializeTemplates", InitializeTemplates, "Manialinks");
+            .AsyncAction("ActionInitializeTemplates", InitializeTemplatesAsync, "Manialinks");
     }
     
-    private static async Task InitializeTemplates(ServicesBuilder s)
+    private static async Task InitializeTemplatesAsync(ServicesBuilder s)
     {
         var maniaLinks = s.GetInstance<IManialinkManager>();
         await maniaLinks.PreprocessAllAsync();
     }
 
-    private static async Task EnableModules(ServicesBuilder s)
+    private static async Task EnableModulesAsync(ServicesBuilder s)
     {
         await s.GetInstance<IManialinkManager>().AddDefaultTemplatesAsync();
         await s.GetInstance<IModuleManager>().EnableModulesAsync();
@@ -140,7 +140,7 @@ private static void SetupControllerManager(ServicesBuilder s)
         pipelineManager.UseEvoScManialinks(s);
     }
 
-    private static async Task SetupModules(ServicesBuilder s)
+    private static async Task SetupModulesAsync(ServicesBuilder s)
     {
         var modules = s.GetInstance<IModuleManager>();
         var config = s.GetInstance<IEvoScBaseConfig>();
@@ -163,7 +163,7 @@ private static async Task SetupModules(ServicesBuilder s)
         await modules.LoadAsync(externalModules);
     }
 
-    private static async Task SetupGbxRemoteConnection(ServicesBuilder s)
+    private static async Task SetupGbxRemoteConnectionAsync(ServicesBuilder s)
     {
         var serverClient = s.GetInstance<IServerClient>();
         s.GetInstance<IServerCallbackHandler>();
diff --git a/src/EvoSC/CliCommands/RunCommand.cs b/src/EvoSC/CliCommands/RunCommand.cs
index 48e41ba2d..5978b7371 100644
--- a/src/EvoSC/CliCommands/RunCommand.cs
+++ b/src/EvoSC/CliCommands/RunCommand.cs
@@ -1,5 +1,4 @@
 using EvoSC.CLI.Attributes;
-using EvoSC.CLI.Models;
 using EvoSC.Common.Application;
 using EvoSC.Common.Config.Models;
 
diff --git a/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs b/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs
index f3ec57a94..032f97ced 100644
--- a/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs
+++ b/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs
@@ -81,7 +81,7 @@ public async Task All_Components_Are_Executed()
         
         startup.Services("TestService", s => s.Register<IMyService, MyService>());
         startup.Action("MyAction", s => actionExecuted = true);
-        startup.ActionAsync("MyAsyncAction", s =>
+        startup.AsyncAction("MyAsyncAction", s =>
         {
             asyncActionExecuted = true;
             return Task.CompletedTask;

From 9153796fedbb636595958d4662234cd300ffe74e Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Wed, 5 Jul 2023 13:43:36 +0200
Subject: [PATCH 15/22] more sonarcloud fixes

---
 src/EvoSC.Common/Application/StartupPipeline.cs        | 7 ++++++-
 src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs | 8 +++++---
 src/EvoSC/Application.cs                               | 1 -
 3 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/EvoSC.Common/Application/StartupPipeline.cs b/src/EvoSC.Common/Application/StartupPipeline.cs
index c43fc3978..24e5dd595 100644
--- a/src/EvoSC.Common/Application/StartupPipeline.cs
+++ b/src/EvoSC.Common/Application/StartupPipeline.cs
@@ -9,7 +9,7 @@
 
 namespace EvoSC.Common.Application;
 
-public class StartupPipeline : IStartupPipeline
+public class StartupPipeline : IStartupPipeline, IDisposable
 {
     private readonly ServicesBuilder _services;
     private readonly ILogger<StartupPipeline> _logger;
@@ -112,4 +112,9 @@ public async Task ExecuteAllAsync()
             await ExecuteComponentAsync(component);
         }
     }
+
+    public void Dispose()
+    {
+        _services.Dispose();
+    }
 }
diff --git a/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs b/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
index 36fa7c63f..9dacc0dad 100644
--- a/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
+++ b/src/EvoSC.Common/Config/Stores/EvoSCBaseConfigStore.cs
@@ -1,4 +1,5 @@
-using Config.Net;
+using System.Globalization;
+using Config.Net;
 using EvoSC.Common.Config.Models;
 
 namespace EvoSC.Common.Config.Stores;
@@ -27,8 +28,9 @@ public void Dispose()
         {
             return null;
         }
-        
-        var enviName = $"EVOSC_{key.Replace(".", "_", StringComparison.Ordinal).ToUpper()}";
+
+        var enviKey = key.Replace(".", "_", StringComparison.Ordinal).ToUpper(CultureInfo.InvariantCulture);
+        var enviName = $"EVOSC_{enviKey}";
         var enviValue = Environment.GetEnvironmentVariable(enviName);
 
         _cliOptions.TryGetValue(key, out var cliValue);
diff --git a/src/EvoSC/Application.cs b/src/EvoSC/Application.cs
index 2e1fcdccb..dd74f86dd 100644
--- a/src/EvoSC/Application.cs
+++ b/src/EvoSC/Application.cs
@@ -2,7 +2,6 @@
 using EvoSC.Common.Config.Models;
 using EvoSC.Common.Interfaces;
 using EvoSC.Modules.Interfaces;
-using Microsoft.Extensions.Logging;
 using SimpleInjector;
 using SimpleInjector.Lifestyles;
 

From a4d972272953388eb09991363fa7fc879f422664 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Fri, 7 Jul 2023 09:47:27 +0200
Subject: [PATCH 16/22] setup dependencies for cli startup pipeline

---
 src/EvoSC.CLI/CliStartup.cs                   | 82 +++++++++++--------
 .../Services/MatchSettingsService.cs          |  4 +-
 .../Services/PlayerCacheService.cs            |  5 +-
 .../ManialinkInteractionHandler.cs            |  5 +-
 src/EvoSC/Application.cs                      |  1 -
 5 files changed, 56 insertions(+), 41 deletions(-)

diff --git a/src/EvoSC.CLI/CliStartup.cs b/src/EvoSC.CLI/CliStartup.cs
index 6fb8d4322..30082be77 100644
--- a/src/EvoSC.CLI/CliStartup.cs
+++ b/src/EvoSC.CLI/CliStartup.cs
@@ -28,73 +28,89 @@ public static void SetupBasePipeline(this IStartupPipeline pipeline, IEvoScBaseC
 
             .Services(AppFeature.Logging, s => s.AddEvoScLogging(config.Logging))
 
-            .Services(AppFeature.DatabaseMigrations, s => s.AddEvoScMigrations())
+            .Services(AppFeature.DatabaseMigrations, s => s
+                    .AddEvoScMigrations()
+                , "Config")
 
             .Services(AppFeature.Database, s => s
                     .AddEvoScDatabase(config.Database)
-                , "DatabaseMigrations")
+                , "DatabaseMigrations", "Logging", "ActionMigrateDatabase")
 
-            .Services(AppFeature.Events, s => s.AddEvoScEvents())
+            .Services(AppFeature.Events, s => s
+                    .AddEvoScEvents()
+                , "Logging", "ControllerManager", "ActionInitializeEventManager")
 
-            .Services(AppFeature.GbxRemoteClient, s => s.AddGbxRemoteClient())
+            .Services(AppFeature.GbxRemoteClient, s => s
+                    .AddGbxRemoteClient()
+                , "Logging", "Config", "Events", "PlayerManager", "ActionPipelines", "InitializeGbxRemoteConnection")
 
-            .Services(AppFeature.Modules, s => s.AddEvoScModules())
+            .Services(AppFeature.Modules, s => s
+                    .AddEvoScModules()
+                , "Logging", "Config", "ControllerManager", "ServicesManager", "ActionPipelines", "Permissions",
+                "Database", "Manialinks")
 
-            .Services(AppFeature.ControllerManager, s => s.AddEvoScControllers())
+            .Services(AppFeature.ControllerManager, s => s
+                    .AddEvoScControllers()
+                , "Logging")
 
             .Services(AppFeature.PlayerManager, s => s
-                .Register<IPlayerManagerService, PlayerManagerService>(Lifestyle.Transient)
-            )
+                    .Register<IPlayerManagerService, PlayerManagerService>(Lifestyle.Transient)
+                , "Logging", "Database", "PlayerCache", "GbxRemoteClient")
 
             .Services(AppFeature.MapsManager, s => s
-                .Register<IMapService, MapService>(Lifestyle.Transient)
-            )
+                    .Register<IMapService, MapService>(Lifestyle.Transient)
+                , "Logging", "Config", "Database", "PlayerManager", "GbxRemoteClient")
 
             .Services(AppFeature.PlayerCache, s => s
-                .RegisterSingleton<IPlayerCacheService, PlayerCacheService>()
-            )
+                    .RegisterSingleton<IPlayerCacheService, PlayerCacheService>()
+                , "Logging", "Events", "Database", "GbxRemoteClient", "ActionInitializePlayerCache")
 
             .Services(AppFeature.MatchSettings, s => s
-                .Register<IMatchSettingsService, MatchSettingsService>(Lifestyle.Transient)
-            )
+                    .Register<IMatchSettingsService, MatchSettingsService>(Lifestyle.Transient)
+                , "Logging", "GbxRemoteClient", "Config")
 
             .Services(AppFeature.Auditing, s => s
-                .Register<IAuditService, AuditService>(Lifestyle.Transient)
-            )
+                    .Register<IAuditService, AuditService>(Lifestyle.Transient)
+                , "Logging", "Database")
 
             .Services(AppFeature.ServicesManager, s => s
-                .RegisterSingleton<IServiceContainerManager, ServiceContainerManager>()
-            )
+                    .RegisterSingleton<IServiceContainerManager, ServiceContainerManager>()
+                , "Logging")
 
-            .Services(AppFeature.ChatCommands, s => s.AddEvoScChatCommands())
+            .Services(AppFeature.ChatCommands, s => s
+                    .AddEvoScChatCommands()
+                , "Logging", "PlayerManager")
 
-            .Services(AppFeature.ActionPipelines, s => s.AddEvoScMiddlewarePipelines())
+            .Services(AppFeature.ActionPipelines, s => s
+                    .AddEvoScMiddlewarePipelines()
+                , "Logging")
 
-            .Services(AppFeature.Permissions, s => s.AddEvoScPermissions())
+            .Services(AppFeature.Permissions, s => s
+                    .AddEvoScPermissions()
+                , "Database")
 
-            .Services(AppFeature.Manialinks, s => s.AddEvoScManialinks())
+            .Services(AppFeature.Manialinks, s => s
+                    .AddEvoScManialinks()
+                , "Logging", "Events", "PlayerManager", "ControllerManager", "PipelineManager", "GbxRemoteClient", "ActionInitializeTemplates")
 
-            .Action("ActionMigrateDatabase", MigrateDatabase, "DatabaseMigrations")
+            .Action("ActionMigrateDatabase", MigrateDatabase)
 
             .Action("ActionInitializeEventManager", s => s
-                    .GetInstance<IEventManager>()
-                , "Events")
+                .GetInstance<IEventManager>()
+            )
 
             .Action("ActionInitializePlayerCache", s => s
-                    .GetInstance<IPlayerCacheService>()
-                , "PlayerCache")
+                .GetInstance<IPlayerCacheService>()
+            )
 
             .Action("ActionInitializeManialinkInteractionHandler", s => s
                     .GetInstance<IManialinkInteractionHandler>()
                 , "ActionInitializeEventManager", "ActionInitializePlayerCache")
 
-            .AsyncAction("InitializeGbxRemoteConnection", SetupGbxRemoteConnectionAsync,
-                "ActionInitializeEventManager",
-                "ActionInitializePlayerCache",
-                "ActionInitializeManialinkInteractionHandler",
-                "GbxRemoteClient")
+            .AsyncAction("InitializeGbxRemoteConnection", SetupGbxRemoteConnectionAsync
+                , "ActionInitializeEventManager", "ActionInitializePlayerCache", "ActionInitializeManialinkInteractionHandler")
 
-            .AsyncAction("ActionInitializeTemplates", InitializeTemplatesAsync, "Manialinks");
+            .AsyncAction("ActionInitializeTemplates", InitializeTemplatesAsync);
     }
     
     private static async Task InitializeTemplatesAsync(ServicesBuilder s)
diff --git a/src/EvoSC.Common/Services/MatchSettingsService.cs b/src/EvoSC.Common/Services/MatchSettingsService.cs
index 948ee12ef..f62f6b927 100644
--- a/src/EvoSC.Common/Services/MatchSettingsService.cs
+++ b/src/EvoSC.Common/Services/MatchSettingsService.cs
@@ -16,14 +16,14 @@ public class MatchSettingsService : IMatchSettingsService
     private readonly ILogger<MatchSettingsService> _logger;
     private readonly IServerClient _server;
     private readonly IEvoScBaseConfig _config;
-    
+
     public MatchSettingsService(ILogger<MatchSettingsService> logger, IServerClient server, IEvoScBaseConfig config)
     {
         _logger = logger;
         _server = server;
         _config = config;
     }
-    
+
     public async Task SetCurrentScriptSettingsAsync(Action<Dictionary<string, object>> settingsAction)
     {
         var settings = await _server.Remote.GetModeScriptSettingsAsync();
diff --git a/src/EvoSC.Common/Services/PlayerCacheService.cs b/src/EvoSC.Common/Services/PlayerCacheService.cs
index e107aa438..61efc2b3d 100644
--- a/src/EvoSC.Common/Services/PlayerCacheService.cs
+++ b/src/EvoSC.Common/Services/PlayerCacheService.cs
@@ -35,12 +35,13 @@ public IEnumerable<IOnlinePlayer> OnlinePlayers
         }
     }
 
-    public PlayerCacheService(IEventManager events, IServerClient server, ILogger<PlayerCacheService> logger, IPlayerRepository playerRepository)
+    public PlayerCacheService(IEventManager events, IServerClient server, ILogger<PlayerCacheService> logger,
+        IPlayerRepository playerRepository)
     {
         _server = server;
         _logger = logger;
         _playerRepository = playerRepository;
-        
+
         SetupEvents(events);
     }
 
diff --git a/src/EvoSC.Manialinks/ManialinkInteractionHandler.cs b/src/EvoSC.Manialinks/ManialinkInteractionHandler.cs
index c2c624c4c..6a2040f5d 100644
--- a/src/EvoSC.Manialinks/ManialinkInteractionHandler.cs
+++ b/src/EvoSC.Manialinks/ManialinkInteractionHandler.cs
@@ -35,13 +35,12 @@ public class ManialinkInteractionHandler : IManialinkInteractionHandler
 
     public ManialinkInteractionHandler(IEventManager events, IManialinkActionManager manialinkActionManager,
         ILogger<ManialinkInteractionHandler> logger, IPlayerManagerService playerManager,
-        IControllerManager controllers, IPlayerManagerService players,
-        IActionPipelineManager actionPipeline)
+        IControllerManager controllers, IActionPipelineManager actionPipeline)
     {
         _manialinkActionManager = manialinkActionManager;
         _logger = logger;
         _controllers = controllers;
-        _players = players;
+        _players = playerManager;
         _actionPipeline = actionPipeline;
 
         SetupValueReader(playerManager);
diff --git a/src/EvoSC/Application.cs b/src/EvoSC/Application.cs
index dd74f86dd..d0956e8b2 100644
--- a/src/EvoSC/Application.cs
+++ b/src/EvoSC/Application.cs
@@ -27,7 +27,6 @@ public Application(IEvoScBaseConfig config)
         StartupPipeline = new StartupPipeline(_config);
 
         StartupPipeline.Services("Application", s => s.RegisterInstance<IEvoSCApplication>(this));
-        StartupPipeline.Services("Config", s => s.RegisterInstance(_config));
 
         ConfigureServiceContainer();
     }

From 7d0d81c6ce67f54e068a879eb1e4f278f034e545 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Fri, 7 Jul 2023 10:29:57 +0200
Subject: [PATCH 17/22] execute services before actions

---
 .../Application/StartupPipeline.cs            | 51 ++++++++++++-------
 .../Application/StartupPipelineTests.cs       | 14 +++++
 2 files changed, 48 insertions(+), 17 deletions(-)

diff --git a/src/EvoSC.Common/Application/StartupPipeline.cs b/src/EvoSC.Common/Application/StartupPipeline.cs
index 24e5dd595..c969a3455 100644
--- a/src/EvoSC.Common/Application/StartupPipeline.cs
+++ b/src/EvoSC.Common/Application/StartupPipeline.cs
@@ -5,6 +5,7 @@
 using EvoSC.Common.Interfaces.Application;
 using EvoSC.Common.Logging;
 using Microsoft.Extensions.Logging;
+using Org.BouncyCastle.Security;
 using SimpleInjector;
 
 namespace EvoSC.Common.Application;
@@ -71,38 +72,54 @@ private async Task ExecuteComponentAsync(IStartupComponent component)
             await asyncActionComponent.AsyncAction(_services);
         }
     }
-    
-    private async Task ExecuteAsyncInternalAsync(IEnumerable<string> components, List<string> dependencyPath)
+
+    private void CreatedDependencyOrder(IEnumerable<string> components, Dictionary<string, IStartupComponent> services,
+        Dictionary<string, IStartupComponent> actions, HashSet<string> previousComponents)
     {
         foreach (var name in components)
         {
-            if (dependencyPath.Contains(name))
+            if (previousComponents.Contains(name))
             {
-                throw new StartupDependencyCycleException(dependencyPath);
+                throw new StartupDependencyCycleException(previousComponents);
             }
             
-            if (_components.TryGetValue(name, out var component))
+            if (!_components.ContainsKey(name))
             {
-                if (component.Dependencies.Count > 0)
-                {
-                    var newPath = new List<string>();
-                    newPath.AddRange(dependencyPath);
-                    newPath.Add(name);
-                    await ExecuteAsyncInternalAsync(component.Dependencies.ToArray(), newPath);
-                }
-
-                await ExecuteComponentAsync(component);
+                throw new StartupPipelineException($"Startup component {name} does not exist.");
+            }
+            
+            var component = _components[name];
+
+            var currentComponents = new HashSet<string>(previousComponents) {name};
+            CreatedDependencyOrder(component.Dependencies, services, actions, currentComponents);
+            
+            if (component is IServiceStartupComponent)
+            {
+                services[name] = component;
             }
             else
             {
-                throw new StartupPipelineException($"Startup component {name} does not exist.");
+                actions[name] = component;
             }
         }
     }
     
-    public Task ExecuteAsync(params string[] components)
+    public async Task ExecuteAsync(params string[] components)
     {
-        return ExecuteAsyncInternalAsync(components, Array.Empty<string>().ToList());
+        var services = new Dictionary<string, IStartupComponent>();
+        var actions = new Dictionary<string, IStartupComponent>();
+
+        CreatedDependencyOrder(components, services, actions, new HashSet<string>());
+
+        foreach (var (_, component) in services)
+        {
+            await ExecuteComponentAsync(component);
+        }
+
+        foreach (var (_, component) in actions)
+        {
+            await ExecuteComponentAsync(component);
+        }
     }
 
     public async Task ExecuteAllAsync()
diff --git a/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs b/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs
index 032f97ced..d0d1e4999 100644
--- a/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs
+++ b/tests/EvoSC.Common.Tests/Application/StartupPipelineTests.cs
@@ -116,4 +116,18 @@ public async Task Startup_Component_Not_Existing_Throws_Exception()
         var startup = new StartupPipeline(_config.Object);
         await Assert.ThrowsAsync<StartupPipelineException>(() => startup.ExecuteAsync("InvalidComponent"));
     }
+
+    [Fact]
+    public async Task Services_Is_Executed_Before_Actions()
+    {
+        var startup = new StartupPipeline(_config.Object);
+
+        startup.Services("MyService", s => throw new Exception("service"), "MyAction");
+        startup.Services("MyService2", s => { }, "MyService");
+        startup.Action("MyAction", s => throw new Exception("action"));
+
+        var exception = await Assert.ThrowsAsync<Exception>(() => startup.ExecuteAsync("MyService2"));
+        
+        Assert.Equal("service", exception.Message);
+    }
 }

From 854cb6b10fcf73b9825342284ae336cf756dd448 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Fri, 7 Jul 2023 10:43:45 +0200
Subject: [PATCH 18/22] fix service container configuration

---
 src/EvoSC.CLI/CliManager.cs                   |  2 +
 .../Application/StartupPipeline.cs            | 73 +++++++++++--------
 .../Services/CommonServiceExtensions.cs       | 10 +++
 src/EvoSC/Application.cs                      | 13 +---
 src/EvoSC/CliCommands/RunCommand.cs           |  2 +-
 5 files changed, 56 insertions(+), 44 deletions(-)

diff --git a/src/EvoSC.CLI/CliManager.cs b/src/EvoSC.CLI/CliManager.cs
index 47f24d649..cab8317fa 100644
--- a/src/EvoSC.CLI/CliManager.cs
+++ b/src/EvoSC.CLI/CliManager.cs
@@ -10,6 +10,7 @@
 using EvoSC.CLI.Models;
 using EvoSC.Common.Application;
 using EvoSC.Common.Config;
+using EvoSC.Common.Services;
 using EvoSC.Common.Util;
 using EvoSC.Common.Util.EnumIdentifier;
 using Microsoft.Extensions.DependencyInjection;
@@ -156,6 +157,7 @@ private async Task ExecuteHandlerAsync(ICliCommandInfo command, InvocationContex
         var config = Configuration.GetBaseConfig(cliConfigOptions);
 
         var startupPipeline = new StartupPipeline(config);
+        startupPipeline.ServiceContainer.ConfigureServiceContainerForEvoSc();
         startupPipeline.SetupBasePipeline(config);
 
         await startupPipeline.ExecuteAsync(command.RequiredFeatures
diff --git a/src/EvoSC.Common/Application/StartupPipeline.cs b/src/EvoSC.Common/Application/StartupPipeline.cs
index c969a3455..29594e51c 100644
--- a/src/EvoSC.Common/Application/StartupPipeline.cs
+++ b/src/EvoSC.Common/Application/StartupPipeline.cs
@@ -16,6 +16,8 @@ public class StartupPipeline : IStartupPipeline, IDisposable
     private readonly ILogger<StartupPipeline> _logger;
     private readonly Dictionary<string, IStartupComponent> _components = new();
     
+    public Container ServiceContainer => _services;
+    
     public StartupPipeline(IEvoScBaseConfig config)
     {
         _services = new ServicesBuilder();
@@ -23,7 +25,41 @@ public StartupPipeline(IEvoScBaseConfig config)
         _logger = new Container().AddEvoScLogging(config.Logging).GetInstance<ILogger<StartupPipeline>>();
     }
 
-    public Container ServiceContainer => _services;
+    private void CreatedDependencyOrder(IEnumerable<string> components, Dictionary<string, IStartupComponent> services,
+        Dictionary<string, IStartupComponent> actions, HashSet<string> previousComponents)
+    {
+        foreach (var name in components)
+        {
+            if (previousComponents.Contains(name))
+            {
+                throw new StartupDependencyCycleException(previousComponents);
+            }
+            
+            if (!_components.ContainsKey(name))
+            {
+                throw new StartupPipelineException($"Startup component {name} does not exist.");
+            }
+            
+            var component = _components[name];
+
+            var currentComponents = new HashSet<string>(previousComponents) {name};
+            CreatedDependencyOrder(component.Dependencies, services, actions, currentComponents);
+            
+            if (component is IServiceStartupComponent)
+            {
+                services[name] = component;
+            }
+            else
+            {
+                actions[name] = component;
+            }
+        }
+    }
+
+    private void LogExecutionSuccess()
+    {
+        _logger.LogDebug("Startup pipeline finished");
+    }
     
     public IStartupPipeline Services(string name, Action<ServicesBuilder> servicesConfig, params string[] dependencies)
     {
@@ -73,37 +109,6 @@ private async Task ExecuteComponentAsync(IStartupComponent component)
         }
     }
 
-    private void CreatedDependencyOrder(IEnumerable<string> components, Dictionary<string, IStartupComponent> services,
-        Dictionary<string, IStartupComponent> actions, HashSet<string> previousComponents)
-    {
-        foreach (var name in components)
-        {
-            if (previousComponents.Contains(name))
-            {
-                throw new StartupDependencyCycleException(previousComponents);
-            }
-            
-            if (!_components.ContainsKey(name))
-            {
-                throw new StartupPipelineException($"Startup component {name} does not exist.");
-            }
-            
-            var component = _components[name];
-
-            var currentComponents = new HashSet<string>(previousComponents) {name};
-            CreatedDependencyOrder(component.Dependencies, services, actions, currentComponents);
-            
-            if (component is IServiceStartupComponent)
-            {
-                services[name] = component;
-            }
-            else
-            {
-                actions[name] = component;
-            }
-        }
-    }
-    
     public async Task ExecuteAsync(params string[] components)
     {
         var services = new Dictionary<string, IStartupComponent>();
@@ -120,6 +125,8 @@ public async Task ExecuteAsync(params string[] components)
         {
             await ExecuteComponentAsync(component);
         }
+        
+        LogExecutionSuccess();
     }
 
     public async Task ExecuteAllAsync()
@@ -128,6 +135,8 @@ public async Task ExecuteAllAsync()
         {
             await ExecuteComponentAsync(component);
         }
+        
+        LogExecutionSuccess();
     }
 
     public void Dispose()
diff --git a/src/EvoSC.Common/Services/CommonServiceExtensions.cs b/src/EvoSC.Common/Services/CommonServiceExtensions.cs
index d384d79ff..a27324122 100644
--- a/src/EvoSC.Common/Services/CommonServiceExtensions.cs
+++ b/src/EvoSC.Common/Services/CommonServiceExtensions.cs
@@ -1,6 +1,7 @@
 using EvoSC.Common.Interfaces.Controllers;
 using EvoSC.Common.Interfaces.Services;
 using SimpleInjector;
+using SimpleInjector.Lifestyles;
 
 namespace EvoSC.Common.Services;
 
@@ -29,4 +30,13 @@ public static Container AddEvoScCommonScopedServices(this Container services)
         
         return services;
     }
+
+    public static void ConfigureServiceContainerForEvoSc(this Container services)
+    {
+        services.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
+        services.Options.EnableAutoVerification = false;
+        services.Options.ResolveUnregisteredConcreteTypes = true;
+        services.Options.SuppressLifestyleMismatchVerification = true;
+        services.Options.UseStrictLifestyleMismatchBehavior = false;
+    }
 }
diff --git a/src/EvoSC/Application.cs b/src/EvoSC/Application.cs
index d0956e8b2..3a2dcb174 100644
--- a/src/EvoSC/Application.cs
+++ b/src/EvoSC/Application.cs
@@ -1,6 +1,7 @@
 using EvoSC.Common.Application;
 using EvoSC.Common.Config.Models;
 using EvoSC.Common.Interfaces;
+using EvoSC.Common.Services;
 using EvoSC.Modules.Interfaces;
 using SimpleInjector;
 using SimpleInjector.Lifestyles;
@@ -26,18 +27,8 @@ public Application(IEvoScBaseConfig config)
         _isDebug = Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") == "Development";
         StartupPipeline = new StartupPipeline(_config);
 
+        StartupPipeline.ServiceContainer.ConfigureServiceContainerForEvoSc();
         StartupPipeline.Services("Application", s => s.RegisterInstance<IEvoSCApplication>(this));
-
-        ConfigureServiceContainer();
-    }
-
-    private void ConfigureServiceContainer()
-    {
-        StartupPipeline.ServiceContainer.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
-        StartupPipeline.ServiceContainer.Options.EnableAutoVerification = false;
-        StartupPipeline.ServiceContainer.Options.ResolveUnregisteredConcreteTypes = true;
-        StartupPipeline.ServiceContainer.Options.SuppressLifestyleMismatchVerification = true;
-        StartupPipeline.ServiceContainer.Options.UseStrictLifestyleMismatchBehavior = false;
     }
 
     public async Task RunAsync()
diff --git a/src/EvoSC/CliCommands/RunCommand.cs b/src/EvoSC/CliCommands/RunCommand.cs
index 5978b7371..256ebb005 100644
--- a/src/EvoSC/CliCommands/RunCommand.cs
+++ b/src/EvoSC/CliCommands/RunCommand.cs
@@ -5,7 +5,7 @@
 namespace EvoSC.CliCommands;
 
 [CliCommand(Name = "run", Description = "Start the server controller.")]
-[RequiredFeatures(AppFeature.Config)]
+[RequiredFeatures(AppFeature.DatabaseMigrations)]
 public class RunCommand
 {
     private readonly IEvoScBaseConfig _config;

From 9a6945cf20a4e0dbaedd4e81ddb1a8262877b644 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Fri, 7 Jul 2023 11:09:32 +0200
Subject: [PATCH 19/22] add comments.

---
 .../Attributes/CliCommandAttribute.cs         |  10 ++
 .../Attributes/RequiredFeaturesAttribute.cs   |   3 +
 src/EvoSC.CLI/CliManager.cs                   | 134 +++++++++---------
 src/EvoSC.CLI/Exceptions/EvoScCliException.cs |   3 +
 .../InvalidCommandClassFormatException.cs     |   3 +
 src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs   |  19 +++
 src/EvoSC.CLI/Interfaces/ICliManager.cs       |  17 +++
 src/EvoSC.CLI/Models/CliEvoScConfig.cs        |   3 +
 src/EvoSC.CLI/Models/CliEvoScConfigBinder.cs  |  15 --
 src/EvoSC.Common/Application/AppFeature.cs    |  57 ++++++++
 .../StartupDependencyCycleException.cs        |   6 +
 .../Exceptions/StartupPipelineException.cs    |   3 +
 .../Application/IActionStartupComponent.cs    |   3 +
 .../IAsyncActionStartupComponent.cs           |   3 +
 .../Application/IServiceStartupComponent.cs   |   3 +
 .../Application/IStartupComponent.cs          |   8 ++
 .../Interfaces/IStartupPipeline.cs            |  56 ++++++++
 src/EvoSC/EvoSC.csproj                        |   4 -
 18 files changed, 264 insertions(+), 86 deletions(-)
 delete mode 100644 src/EvoSC.CLI/Models/CliEvoScConfigBinder.cs

diff --git a/src/EvoSC.CLI/Attributes/CliCommandAttribute.cs b/src/EvoSC.CLI/Attributes/CliCommandAttribute.cs
index 014b7d3c6..e0a204685 100644
--- a/src/EvoSC.CLI/Attributes/CliCommandAttribute.cs
+++ b/src/EvoSC.CLI/Attributes/CliCommandAttribute.cs
@@ -1,8 +1,18 @@
 namespace EvoSC.CLI.Attributes;
 
+/// <summary>
+/// Define a class as a CLI command handler.
+/// </summary>
 [AttributeUsage(AttributeTargets.Class)]
 public class CliCommandAttribute : Attribute
 {
+    /// <summary>
+    /// The name of the CLI command. Must alphanumeric.
+    /// </summary>
     public required string Name { get; init; }
+    
+    /// <summary>
+    /// A short summary describing what this command does.
+    /// </summary>
     public required string Description { get; init; }
 }
diff --git a/src/EvoSC.CLI/Attributes/RequiredFeaturesAttribute.cs b/src/EvoSC.CLI/Attributes/RequiredFeaturesAttribute.cs
index c459c7921..4c6415cfb 100644
--- a/src/EvoSC.CLI/Attributes/RequiredFeaturesAttribute.cs
+++ b/src/EvoSC.CLI/Attributes/RequiredFeaturesAttribute.cs
@@ -2,6 +2,9 @@
 
 namespace EvoSC.CLI.Attributes;
 
+/// <summary>
+/// Define a required Application Feature for a command.
+/// </summary>
 [AttributeUsage(AttributeTargets.Class)]
 public class RequiredFeaturesAttribute :  Attribute
 {
diff --git a/src/EvoSC.CLI/CliManager.cs b/src/EvoSC.CLI/CliManager.cs
index cab8317fa..9535382dd 100644
--- a/src/EvoSC.CLI/CliManager.cs
+++ b/src/EvoSC.CLI/CliManager.cs
@@ -46,73 +46,6 @@ public CliManager()
             .CancelOnProcessTermination()
             .Build();
     }
-    
-    public ICliManager RegisterCommands(Assembly assembly)
-    {
-        foreach (var cmdClass in assembly.AssemblyTypesWithAttribute<CliCommandAttribute>())
-        {
-            RegisterCommand(cmdClass);
-        }
-
-        return this;
-    }
-
-    public ICliManager RegisterCommand(Type cmdClass)
-    {
-        var handlerMethod = cmdClass.GetMethod("ExecuteAsync");
-
-        if (handlerMethod == null)
-        {
-            throw new InvalidCommandClassFormatException(
-                $"Did not find the ExecuteAsync method in CLI command: {cmdClass.Name}");
-        }
-        
-        var cmdAttr = cmdClass.GetCustomAttribute<CliCommandAttribute>();
-
-        if (cmdAttr == null)
-        {
-            throw new InvalidCommandClassFormatException("Missing CliCommand");
-        }
-        
-        var requiredFeatures = cmdClass.GetCustomAttribute<RequiredFeaturesAttribute>();
-
-        var command = new Command(cmdAttr!.Name, cmdAttr.Description);
-
-        var options = new List<Option>();
-        foreach (var param in handlerMethod.GetParameters())
-        {
-            var option = CreateOption(param);
-
-            if (option == null)
-            {
-                throw new InvalidOperationException($"Failed to create option for CLI command {cmdClass.Name}");
-            }
-
-            options.Add(option);
-            command.AddOption(option);
-        }
-            
-        options.Add(_configOption);
-
-        var commandInfo = new CliCommandInfo
-        {
-            Command = command,
-            CommandClass = cmdClass,
-            HandlerMethod = handlerMethod,
-            Options = options.ToArray(),
-            RequiredFeatures = requiredFeatures?.Features ?? Array.Empty<AppFeature>()
-        };
-
-        command.SetHandler(async context =>
-        {
-            await ExecuteHandlerAsync(commandInfo, context);
-        });
-
-        _registeredCommands.Add(commandInfo);
-        _rootCommand.AddCommand(command);
-
-        return this;
-    }
 
     private async Task ExecuteHandlerAsync(ICliCommandInfo command, InvocationContext context)
     {
@@ -194,6 +127,73 @@ await startupPipeline.ExecuteAsync(command.RequiredFeatures
 
         return option;
     }
+    
+    public ICliManager RegisterCommands(Assembly assembly)
+    {
+        foreach (var cmdClass in assembly.AssemblyTypesWithAttribute<CliCommandAttribute>())
+        {
+            RegisterCommand(cmdClass);
+        }
+
+        return this;
+    }
+
+    public ICliManager RegisterCommand(Type cmdClass)
+    {
+        var handlerMethod = cmdClass.GetMethod("ExecuteAsync");
+
+        if (handlerMethod == null)
+        {
+            throw new InvalidCommandClassFormatException(
+                $"Did not find the ExecuteAsync method in CLI command: {cmdClass.Name}");
+        }
+        
+        var cmdAttr = cmdClass.GetCustomAttribute<CliCommandAttribute>();
+
+        if (cmdAttr == null)
+        {
+            throw new InvalidCommandClassFormatException("Missing CliCommand");
+        }
+        
+        var requiredFeatures = cmdClass.GetCustomAttribute<RequiredFeaturesAttribute>();
+
+        var command = new Command(cmdAttr!.Name, cmdAttr.Description);
+
+        var options = new List<Option>();
+        foreach (var param in handlerMethod.GetParameters())
+        {
+            var option = CreateOption(param);
+
+            if (option == null)
+            {
+                throw new InvalidOperationException($"Failed to create option for CLI command {cmdClass.Name}");
+            }
+
+            options.Add(option);
+            command.AddOption(option);
+        }
+            
+        options.Add(_configOption);
+
+        var commandInfo = new CliCommandInfo
+        {
+            Command = command,
+            CommandClass = cmdClass,
+            HandlerMethod = handlerMethod,
+            Options = options.ToArray(),
+            RequiredFeatures = requiredFeatures?.Features ?? Array.Empty<AppFeature>()
+        };
+
+        command.SetHandler(async context =>
+        {
+            await ExecuteHandlerAsync(commandInfo, context);
+        });
+
+        _registeredCommands.Add(commandInfo);
+        _rootCommand.AddCommand(command);
+
+        return this;
+    }
 
     public Task<int> ExecuteAsync(string[] args)
     {
diff --git a/src/EvoSC.CLI/Exceptions/EvoScCliException.cs b/src/EvoSC.CLI/Exceptions/EvoScCliException.cs
index 48dfbb7a2..05ed7133b 100644
--- a/src/EvoSC.CLI/Exceptions/EvoScCliException.cs
+++ b/src/EvoSC.CLI/Exceptions/EvoScCliException.cs
@@ -1,5 +1,8 @@
 namespace EvoSC.CLI.Exceptions;
 
+/// <summary>
+/// Exception that occured within the CLI handler.
+/// </summary>
 public class EvoScCliException : Exception
 {
     public EvoScCliException()
diff --git a/src/EvoSC.CLI/Exceptions/InvalidCommandClassFormatException.cs b/src/EvoSC.CLI/Exceptions/InvalidCommandClassFormatException.cs
index 5bbc58122..cb3385e56 100644
--- a/src/EvoSC.CLI/Exceptions/InvalidCommandClassFormatException.cs
+++ b/src/EvoSC.CLI/Exceptions/InvalidCommandClassFormatException.cs
@@ -1,5 +1,8 @@
 namespace EvoSC.CLI.Exceptions;
 
+/// <summary>
+/// Exception which occurs when a command class is not defined correctly.
+/// </summary>
 public class InvalidCommandClassFormatException : EvoScCliException
 {
     public InvalidCommandClassFormatException(string? message) : base(message)
diff --git a/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs b/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs
index 7b966762c..bb3303c83 100644
--- a/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs
+++ b/src/EvoSC.CLI/Interfaces/ICliCommandInfo.cs
@@ -6,9 +6,28 @@ namespace EvoSC.CLI.Interfaces;
 
 public interface ICliCommandInfo
 {
+    /// <summary>
+    /// The command object for this command.
+    /// </summary>
     public Command Command { get; }
+    
+    /// <summary>
+    /// The class definition of this command.
+    /// </summary>
     public Type CommandClass { get; }
+    
+    /// <summary>
+    /// The callback method for this command.
+    /// </summary>
     public MethodInfo HandlerMethod { get; }
+    
+    /// <summary>
+    /// CLI options available for this command.
+    /// </summary>
     public Option[] Options { get; }
+    
+    /// <summary>
+    /// Application Features required to run this command.
+    /// </summary>
     public AppFeature[] RequiredFeatures { get; }
 }
diff --git a/src/EvoSC.CLI/Interfaces/ICliManager.cs b/src/EvoSC.CLI/Interfaces/ICliManager.cs
index 191e4cd7d..4bcf1d112 100644
--- a/src/EvoSC.CLI/Interfaces/ICliManager.cs
+++ b/src/EvoSC.CLI/Interfaces/ICliManager.cs
@@ -4,7 +4,24 @@ namespace EvoSC.CLI.Interfaces;
 
 public interface ICliManager
 {
+    /// <summary>
+    /// Register CLI commands defined in an assembly with the CliCommand attribute.
+    /// </summary>
+    /// <param name="assembly">Assembly to search in.</param>
+    /// <returns></returns>
     public ICliManager RegisterCommands(Assembly assembly);
+    
+    /// <summary>
+    /// Register a single class as a CLI command.
+    /// </summary>
+    /// <param name="cmdClass">The class containing CLI command definition.</param>
+    /// <returns></returns>
     public ICliManager RegisterCommand(Type cmdClass);
+    
+    /// <summary>
+    /// Run the CLI handler.
+    /// </summary>
+    /// <param name="args">CLI arguments to process.</param>
+    /// <returns></returns>
     public Task<int> ExecuteAsync(string[] args);
 }
diff --git a/src/EvoSC.CLI/Models/CliEvoScConfig.cs b/src/EvoSC.CLI/Models/CliEvoScConfig.cs
index e6deea629..329fcd61f 100644
--- a/src/EvoSC.CLI/Models/CliEvoScConfig.cs
+++ b/src/EvoSC.CLI/Models/CliEvoScConfig.cs
@@ -2,5 +2,8 @@
 
 public class CliEvoScConfig
 {
+    /// <summary>
+    /// Key/Value pairs presenting a config value set through the CLI.
+    /// </summary>
     public Dictionary<string, object> Options { get; set; }
 }
diff --git a/src/EvoSC.CLI/Models/CliEvoScConfigBinder.cs b/src/EvoSC.CLI/Models/CliEvoScConfigBinder.cs
deleted file mode 100644
index 3da489df8..000000000
--- a/src/EvoSC.CLI/Models/CliEvoScConfigBinder.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System.CommandLine.Binding;
-
-namespace EvoSC.CLI.Models;
-
-public class CliEvoScConfigBinder : BinderBase<CliEvoScConfig>
-{
-    
-    
-    protected override CliEvoScConfig GetBoundValue(BindingContext bindingContext)
-    {
-        return new CliEvoScConfig {Options = new Dictionary<string, object>()};
-    }
-    
-    
-}
diff --git a/src/EvoSC.Common/Application/AppFeature.cs b/src/EvoSC.Common/Application/AppFeature.cs
index ee2a3f65a..cc04675d2 100644
--- a/src/EvoSC.Common/Application/AppFeature.cs
+++ b/src/EvoSC.Common/Application/AppFeature.cs
@@ -4,59 +4,116 @@ namespace EvoSC.Common.Application;
 
 public enum AppFeature
 {
+    /// <summary>
+    /// All features available in EvoSC.
+    /// </summary>
     All,
     
+    /// <summary>
+    /// The EvoSC base configuration.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     Config,
     
+    /// <summary>
+    /// The standard EvoSC logger.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     Logging,
     
+    /// <summary>
+    /// Standard EvoSC database migrations.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     DatabaseMigrations,
     
+    /// <summary>
+    /// Database connection and repositories.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     Database,
     
+    /// <summary>
+    /// The event system.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     Events,
     
+    /// <summary>
+    /// Connection to the Trackmania server through XMLRPC.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     GbxRemoteClient,
     
+    /// <summary>
+    /// The module system.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     Modules,
     
+    /// <summary>
+    /// Controller framework and manager.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     ControllerManager,
     
+    /// <summary>
+    /// Player manager to manage players offline and online.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     PlayerManager,
     
+    /// <summary>
+    /// Maps manager to manage, add or remove maps.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     MapsManager,
     
+    /// <summary>
+    /// Cache for fast retrieval of player information.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     PlayerCache,
     
+    /// <summary>
+    /// Features to manage match settings and game mode.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     MatchSettings,
     
+    /// <summary>
+    /// Audit logging.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     Auditing,
     
+    /// <summary>
+    /// Manager for multi-service-container features. Mostly used for modules.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     ServicesManager,
     
+    /// <summary>
+    /// Chat command framework.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     ChatCommands,
     
+    /// <summary>
+    /// Middlewares and action pipelines.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     ActionPipelines,
     
+    /// <summary>
+    /// Player groups and permissions.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     Permissions,
     
+    /// <summary>
+    /// Manage, add, remove, display manialinks and respond to actions. The manialink framework.
+    /// </summary>
     [Identifier(NoPrefix = true)]
     Manialinks
 }
diff --git a/src/EvoSC.Common/Application/Exceptions/StartupDependencyCycleException.cs b/src/EvoSC.Common/Application/Exceptions/StartupDependencyCycleException.cs
index 50c6720f1..5d4ad8c8e 100644
--- a/src/EvoSC.Common/Application/Exceptions/StartupDependencyCycleException.cs
+++ b/src/EvoSC.Common/Application/Exceptions/StartupDependencyCycleException.cs
@@ -1,7 +1,13 @@
 namespace EvoSC.Common.Application.Exceptions;
 
+/// <summary>
+/// Exception that occurs when the startup pipeline detects a dependency cycle.
+/// </summary>
 public class StartupDependencyCycleException : StartupPipelineException
 {
+    /// <summary>
+    /// </summary>
+    /// <param name="dependencyPath">The path which the cycle occurs in.</param>
     public StartupDependencyCycleException(IEnumerable<string> dependencyPath) : 
         base($"Startup dependency cycle detected: {string.Join(" -> ", dependencyPath)}")
     {
diff --git a/src/EvoSC.Common/Application/Exceptions/StartupPipelineException.cs b/src/EvoSC.Common/Application/Exceptions/StartupPipelineException.cs
index 28b0cd51b..6a918e9c0 100644
--- a/src/EvoSC.Common/Application/Exceptions/StartupPipelineException.cs
+++ b/src/EvoSC.Common/Application/Exceptions/StartupPipelineException.cs
@@ -1,5 +1,8 @@
 namespace EvoSC.Common.Application.Exceptions;
 
+/// <summary>
+/// General exception for the startup pipeline.
+/// </summary>
 public class StartupPipelineException : Exception
 {
     public StartupPipelineException()
diff --git a/src/EvoSC.Common/Interfaces/Application/IActionStartupComponent.cs b/src/EvoSC.Common/Interfaces/Application/IActionStartupComponent.cs
index 94d7814e0..5c5675cca 100644
--- a/src/EvoSC.Common/Interfaces/Application/IActionStartupComponent.cs
+++ b/src/EvoSC.Common/Interfaces/Application/IActionStartupComponent.cs
@@ -4,5 +4,8 @@ namespace EvoSC.Common.Interfaces.Application;
 
 public interface IActionStartupComponent : IStartupComponent
 {
+    /// <summary>
+    /// The method to call for this action.
+    /// </summary>
     public Action<ServicesBuilder> Action { get; }
 }
diff --git a/src/EvoSC.Common/Interfaces/Application/IAsyncActionStartupComponent.cs b/src/EvoSC.Common/Interfaces/Application/IAsyncActionStartupComponent.cs
index 4e326f7db..d79722033 100644
--- a/src/EvoSC.Common/Interfaces/Application/IAsyncActionStartupComponent.cs
+++ b/src/EvoSC.Common/Interfaces/Application/IAsyncActionStartupComponent.cs
@@ -4,5 +4,8 @@ namespace EvoSC.Common.Interfaces.Application;
 
 public interface IAsyncActionStartupComponent : IStartupComponent
 {
+    /// <summary>
+    /// The method to call for this action.
+    /// </summary>
     public Func<ServicesBuilder, Task> AsyncAction { get; }
 }
diff --git a/src/EvoSC.Common/Interfaces/Application/IServiceStartupComponent.cs b/src/EvoSC.Common/Interfaces/Application/IServiceStartupComponent.cs
index 4d09a1d8f..d00c4a4ea 100644
--- a/src/EvoSC.Common/Interfaces/Application/IServiceStartupComponent.cs
+++ b/src/EvoSC.Common/Interfaces/Application/IServiceStartupComponent.cs
@@ -4,5 +4,8 @@ namespace EvoSC.Common.Interfaces.Application;
 
 public interface IServiceStartupComponent : IStartupComponent
 {
+    /// <summary>
+    /// The method to call to configure the services.
+    /// </summary>
     public Action<ServicesBuilder> ConfigAction { get; }
 }
diff --git a/src/EvoSC.Common/Interfaces/Application/IStartupComponent.cs b/src/EvoSC.Common/Interfaces/Application/IStartupComponent.cs
index 7df1f5c46..2273a9189 100644
--- a/src/EvoSC.Common/Interfaces/Application/IStartupComponent.cs
+++ b/src/EvoSC.Common/Interfaces/Application/IStartupComponent.cs
@@ -2,6 +2,14 @@
 
 public interface IStartupComponent
 {
+    /// <summary>
+    /// Name of the component.
+    /// </summary>
     public string Name { get; }
+    
+    /// <summary>
+    /// Dependencies required to execute this component. Keep in mind that actions are always
+    /// executed after services.
+    /// </summary>
     public List<string> Dependencies { get; }
 }
diff --git a/src/EvoSC.Common/Interfaces/IStartupPipeline.cs b/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
index 63cdd1a02..38f494c1a 100644
--- a/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
+++ b/src/EvoSC.Common/Interfaces/IStartupPipeline.cs
@@ -6,22 +6,78 @@ namespace EvoSC.Common.Interfaces;
 
 public interface IStartupPipeline
 {
+    /// <summary>
+    /// The service container managed and built by this startup pipeline.
+    /// </summary>
     public Container ServiceContainer { get; }
     
+    /// <summary>
+    /// Add a step to configure services.
+    /// </summary>
+    /// <param name="name">Name of the step.</param>
+    /// <param name="servicesConfig">Action to configure the needed services.</param>
+    /// <param name="dependencies">Dependencies required to run this step.</param>
+    /// <returns></returns>
     public IStartupPipeline Services(string name, Action<ServicesBuilder> servicesConfig, params string[] dependencies);
 
+    /// <summary>
+    /// Add a step to configure services.
+    /// </summary>
+    /// <param name="name">Name of the step.</param>
+    /// <param name="servicesConfig">Action to configure the needed services.</param>
+    /// <param name="dependencies">Dependencies required to run this step.</param>
+    /// <returns></returns>
     public IStartupPipeline Services(Enum name, Action<ServicesBuilder> servicesConfig, params string[] dependencies) =>
         Services(name.GetIdentifier(), servicesConfig, dependencies);
+    
+    /// <summary>
+    /// Add a step to execute a generic action.
+    /// </summary>
+    /// <param name="name">Name of the action.</param>
+    /// <param name="actionFunc">The action to be executed.</param>
+    /// <param name="dependencies">Dependencies required to run this action.</param>
+    /// <returns></returns>
     public IStartupPipeline Action(string name, Action<ServicesBuilder> actionFunc, params string[] dependencies);
 
+    /// <summary>
+    /// Add a step to execute a generic action.
+    /// </summary>
+    /// <param name="name">Name of the action.</param>
+    /// <param name="actionFunc">The action to be executed.</param>
+    /// <param name="dependencies">Dependencies required to run this action.</param>
+    /// <returns></returns>
     public IStartupPipeline Action(Enum name, Action<ServicesBuilder> actionFunc, params string[] dependencies) =>
         Action(name.GetIdentifier(), actionFunc, dependencies);
     
+    /// <summary>
+    /// Add a step to execute a generic async action.
+    /// </summary>
+    /// <param name="name">Name of the action.</param>
+    /// <param name="actionFunc">The action to be executed.</param>
+    /// <param name="dependencies">Dependencies required to run this action.</param>
+    /// <returns></returns>
     public IStartupPipeline AsyncAction(string name, Func<ServicesBuilder, Task> actionFunc, params string[] dependencies);
 
+    /// <summary>
+    /// Add a step to execute a generic async action.
+    /// </summary>
+    /// <param name="name">Name of the action.</param>
+    /// <param name="actionFunc">The action to be executed.</param>
+    /// <param name="dependencies">Dependencies required to run this action.</param>
+    /// <returns></returns>
     public IStartupPipeline AsyncAction(Enum name, Func<ServicesBuilder, Task> actionFunc, params string[] dependencies) =>
         AsyncAction(name.GetIdentifier(), actionFunc, dependencies);
 
+    /// <summary>
+    /// Execute the given components/steps in the pipeline.
+    /// </summary>
+    /// <param name="components">The components to execute.</param>
+    /// <returns></returns>
     public Task ExecuteAsync(params string[] components);
+    
+    /// <summary>
+    /// Execute all components in the pipeline in the defined order.
+    /// </summary>
+    /// <returns></returns>
     public Task ExecuteAllAsync();
 }
diff --git a/src/EvoSC/EvoSC.csproj b/src/EvoSC/EvoSC.csproj
index a6aa084ab..7efaee0d7 100644
--- a/src/EvoSC/EvoSC.csproj
+++ b/src/EvoSC/EvoSC.csproj
@@ -33,9 +33,5 @@
     <ItemGroup>
         <Content Include="bin\Debug\net7.0\config\main.toml" />
     </ItemGroup>
-
-    <ItemGroup>
-      <Folder Include="Interfaces\" />
-    </ItemGroup>
     
 </Project>

From d5b95b4e923eaa7514d8096c286c8a06f359d401 Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Fri, 7 Jul 2023 11:10:04 +0200
Subject: [PATCH 20/22] fix sonarcloud issues

---
 src/EvoSC.Common/Application/StartupPipeline.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/EvoSC.Common/Application/StartupPipeline.cs b/src/EvoSC.Common/Application/StartupPipeline.cs
index 29594e51c..f84f85fb8 100644
--- a/src/EvoSC.Common/Application/StartupPipeline.cs
+++ b/src/EvoSC.Common/Application/StartupPipeline.cs
@@ -5,7 +5,6 @@
 using EvoSC.Common.Interfaces.Application;
 using EvoSC.Common.Logging;
 using Microsoft.Extensions.Logging;
-using Org.BouncyCastle.Security;
 using SimpleInjector;
 
 namespace EvoSC.Common.Application;

From 25953518ee26eba1de9388035c45ca1805d6ed1b Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Fri, 7 Jul 2023 11:19:17 +0200
Subject: [PATCH 21/22] fix sonarcloud again

---
 src/EvoSC/Application.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/EvoSC/Application.cs b/src/EvoSC/Application.cs
index 3a2dcb174..29e5bd659 100644
--- a/src/EvoSC/Application.cs
+++ b/src/EvoSC/Application.cs
@@ -4,7 +4,6 @@
 using EvoSC.Common.Services;
 using EvoSC.Modules.Interfaces;
 using SimpleInjector;
-using SimpleInjector.Lifestyles;
 
 namespace EvoSC;
 

From f66aea0128ed54d0d6e9297906e48ae0ac4decfe Mon Sep 17 00:00:00 2001
From: snixtho <snixtho@gmail.com>
Date: Fri, 7 Jul 2023 20:24:03 +0200
Subject: [PATCH 22/22] fix cli cmd aliases and add some more comments

---
 src/EvoSC.CLI/CliManager.cs                   |  4 +--
 src/EvoSC.CLI/CliStartup.cs                   | 14 ++++++++++
 .../Util/EnumIdentifier/AliasAttribute.cs     |  2 +-
 src/EvoSC/ApplicationSetup.cs                 | 26 +++++++++++++++++++
 src/EvoSC/CliCommands/RunCommand.cs           |  5 ++--
 5 files changed, 46 insertions(+), 5 deletions(-)

diff --git a/src/EvoSC.CLI/CliManager.cs b/src/EvoSC.CLI/CliManager.cs
index 9535382dd..fedfdb753 100644
--- a/src/EvoSC.CLI/CliManager.cs
+++ b/src/EvoSC.CLI/CliManager.cs
@@ -113,8 +113,8 @@ await startupPipeline.ExecuteAsync(command.RequiredFeatures
 
     private Option? CreateOption(ParameterInfo param)
     {
-        var cmdOptionType = typeof(Option<>).MakeGenericType(new[] {param.ParameterType});
-        var aliases = cmdOptionType
+        var cmdOptionType = typeof(Option<>).MakeGenericType(param.ParameterType);
+        var aliases = param
             .GetCustomAttributes<AliasAttribute>()
             .Select(a => a.Name)
             .ToList();
diff --git a/src/EvoSC.CLI/CliStartup.cs b/src/EvoSC.CLI/CliStartup.cs
index 30082be77..a63a15fef 100644
--- a/src/EvoSC.CLI/CliStartup.cs
+++ b/src/EvoSC.CLI/CliStartup.cs
@@ -24,6 +24,7 @@ public static class CliStartup
     public static void SetupBasePipeline(this IStartupPipeline pipeline, IEvoScBaseConfig config)
     {
         pipeline
+                // Set up service container
             .Services(AppFeature.Config, s => s.RegisterInstance(config))
 
             .Services(AppFeature.Logging, s => s.AddEvoScLogging(config.Logging))
@@ -93,6 +94,7 @@ public static void SetupBasePipeline(this IStartupPipeline pipeline, IEvoScBaseC
                     .AddEvoScManialinks()
                 , "Logging", "Events", "PlayerManager", "ControllerManager", "PipelineManager", "GbxRemoteClient", "ActionInitializeTemplates")
 
+                // initialization of features
             .Action("ActionMigrateDatabase", MigrateDatabase)
 
             .Action("ActionInitializeEventManager", s => s
@@ -113,12 +115,20 @@ public static void SetupBasePipeline(this IStartupPipeline pipeline, IEvoScBaseC
             .AsyncAction("ActionInitializeTemplates", InitializeTemplatesAsync);
     }
     
+    /// <summary>
+    /// Initialize and preprocess all registered templates.
+    /// </summary>
+    /// <param name="s"></param>
     private static async Task InitializeTemplatesAsync(ServicesBuilder s)
     {
         var maniaLinks = s.GetInstance<IManialinkManager>();
         await maniaLinks.PreprocessAllAsync();
     }
 
+    /// <summary>
+    /// Run database migrations.
+    /// </summary>
+    /// <param name="s"></param>
     private static void MigrateDatabase(ServicesBuilder s)
     {
         using var scope = new Scope(s);
@@ -128,6 +138,10 @@ private static void MigrateDatabase(ServicesBuilder s)
         manager.MigrateFromAssembly(typeof(MigrationManager).Assembly);
     }
 
+    /// <summary>
+    /// Connect to XMLRPC and initialize server callback and chat router.
+    /// </summary>
+    /// <param name="s"></param>
     private static async Task SetupGbxRemoteConnectionAsync(ServicesBuilder s)
     {
         var serverClient = s.GetInstance<IServerClient>();
diff --git a/src/EvoSC.Common/Util/EnumIdentifier/AliasAttribute.cs b/src/EvoSC.Common/Util/EnumIdentifier/AliasAttribute.cs
index 262e12834..c1b4ae45d 100644
--- a/src/EvoSC.Common/Util/EnumIdentifier/AliasAttribute.cs
+++ b/src/EvoSC.Common/Util/EnumIdentifier/AliasAttribute.cs
@@ -1,6 +1,6 @@
 namespace EvoSC.Common.Util.EnumIdentifier;
 
-[AttributeUsage(AttributeTargets.Enum | AttributeTargets.Field, AllowMultiple = true)]
+[AttributeUsage(AttributeTargets.Enum | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = true)]
 public class AliasAttribute : Attribute
 {
     /// <summary>
diff --git a/src/EvoSC/ApplicationSetup.cs b/src/EvoSC/ApplicationSetup.cs
index 94778cbaa..1516d01f6 100644
--- a/src/EvoSC/ApplicationSetup.cs
+++ b/src/EvoSC/ApplicationSetup.cs
@@ -29,6 +29,7 @@ public static class ApplicationSetup
     public static void SetupPipeline(this IStartupPipeline pipeline, IEvoScBaseConfig config)
     {
         pipeline
+                // Setting up service container
             .Services(AppFeature.Config, s => s.RegisterInstance(config))
 
             .Services(AppFeature.Logging, s => s.AddEvoScLogging(config.Logging))
@@ -79,6 +80,7 @@ public static void SetupPipeline(this IStartupPipeline pipeline, IEvoScBaseConfi
 
             .Services(AppFeature.Manialinks, s => s.AddEvoScManialinks())
 
+                // initialize the application
             .Action("ActionMigrateDatabase", MigrateDatabase)
 
             .Action("ActionSetupControllerManager", SetupControllerManager)
@@ -104,18 +106,30 @@ public static void SetupPipeline(this IStartupPipeline pipeline, IEvoScBaseConfi
             .AsyncAction("ActionInitializeTemplates", InitializeTemplatesAsync, "Manialinks");
     }
     
+    /// <summary>
+    /// Preprocesses manialinks.
+    /// </summary>
+    /// <param name="s"></param>
     private static async Task InitializeTemplatesAsync(ServicesBuilder s)
     {
         var maniaLinks = s.GetInstance<IManialinkManager>();
         await maniaLinks.PreprocessAllAsync();
     }
 
+    /// <summary>
+    /// Enables internal and external modules.
+    /// </summary>
+    /// <param name="s"></param>
     private static async Task EnableModulesAsync(ServicesBuilder s)
     {
         await s.GetInstance<IManialinkManager>().AddDefaultTemplatesAsync();
         await s.GetInstance<IModuleManager>().EnableModulesAsync();
     }
 
+    /// <summary>
+    /// Run database migrations.
+    /// </summary>
+    /// <param name="s"></param>
     private static void MigrateDatabase(ServicesBuilder s)
     {
         using var scope = new Scope(s);
@@ -128,6 +142,10 @@ private static void MigrateDatabase(ServicesBuilder s)
         manager.RunInternalModuleMigrations();
     }
 
+    /// <summary>
+    /// Initialize controller registries and set up command and manialink controller managers.
+    /// </summary>
+    /// <param name="s"></param>
     private static void SetupControllerManager(ServicesBuilder s)
     {
         var controllers = s.GetInstance<IControllerManager>();
@@ -140,6 +158,10 @@ private static void SetupControllerManager(ServicesBuilder s)
         pipelineManager.UseEvoScManialinks(s);
     }
 
+    /// <summary>
+    /// Load internal and external modules.
+    /// </summary>
+    /// <param name="s"></param>
     private static async Task SetupModulesAsync(ServicesBuilder s)
     {
         var modules = s.GetInstance<IModuleManager>();
@@ -163,6 +185,10 @@ private static async Task SetupModulesAsync(ServicesBuilder s)
         await modules.LoadAsync(externalModules);
     }
 
+    /// <summary>
+    /// Connect to XMLRPC and set up callback handler and chat router.
+    /// </summary>
+    /// <param name="s"></param>
     private static async Task SetupGbxRemoteConnectionAsync(ServicesBuilder s)
     {
         var serverClient = s.GetInstance<IServerClient>();
diff --git a/src/EvoSC/CliCommands/RunCommand.cs b/src/EvoSC/CliCommands/RunCommand.cs
index 256ebb005..b855e93ed 100644
--- a/src/EvoSC/CliCommands/RunCommand.cs
+++ b/src/EvoSC/CliCommands/RunCommand.cs
@@ -1,11 +1,12 @@
 using EvoSC.CLI.Attributes;
 using EvoSC.Common.Application;
 using EvoSC.Common.Config.Models;
+using EvoSC.Common.Util.EnumIdentifier;
 
 namespace EvoSC.CliCommands;
 
 [CliCommand(Name = "run", Description = "Start the server controller.")]
-[RequiredFeatures(AppFeature.DatabaseMigrations)]
+[RequiredFeatures(AppFeature.Config)]
 public class RunCommand
 {
     private readonly IEvoScBaseConfig _config;
@@ -15,7 +16,7 @@ public RunCommand(IEvoScBaseConfig config)
         _config = config;
     }
     
-    public async Task ExecuteAsync()
+    public async Task ExecuteAsync([Alias(Name = "-s")]int something)
     {
         var app = new Application(_config);
         await app.RunAsync();