Program.cs

using System.Threading.RateLimiting;
using CortexRemote.Endpoints;
using CortexRemote.Middleware;
using CortexRemote.Windows;
using CortexRemote.Windows.Security;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Json;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.IdentityModel.Tokens;
using Scalar.AspNetCore;
using Serilog;

var builder = WebApplication.CreateBuilder();

builder.Host.UseSerilog((context, loggerConfiguration) =>
    loggerConfiguration.ReadFrom.Configuration(context.Configuration));

var configuration = builder.Services.BuildServiceProvider().GetRequiredService<IConfiguration>();

builder.Services.AddSingleton<IKeyHandler, KeyHandler>();
var rsa = builder.Services.BuildServiceProvider().GetRequiredService<IKeyHandler>();

builder.WebHost.ConfigureKestrel(config =>
{
    config.ListenAnyIP(configuration.GetValue<int>("Configuration:Port"));
});

builder.Services.Configure<JsonOptions>(options =>
{
    options.SerializerOptions.Converters.Add(new JsonDateTimeConverter());
});

builder.Services.AddOpenApi(options =>
{
    options.AddDocumentTransformer<BearerSecuritySchemeTransformer>();
});
builder.Services.AddAuthentication()
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = DirectoryManager.APPLICATION_NAME_FOLDER,
            ValidAudience = DirectoryManager.APPLICATION_NAME_FOLDER + 
                            Environment.MachineName,
            ClockSkew = TimeSpan.Zero,
            IssuerSigningKey = new RsaSecurityKey(
                rsa.ImportAsymmetricKey(KeyHandler.SigningKeyFileName))
        };
    });

builder.Services.AddAuthorization();

builder.Services.AddRateLimiter(rateLimiterOptions =>
{
    rateLimiterOptions.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
    
    rateLimiterOptions.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(httpContext =>
        RateLimitPartition.GetFixedWindowLimiter(
            partitionKey: httpContext.User.Identity?.Name ?? 
                          httpContext.Request.Headers.Host.ToString(),
            factory: _ => new FixedWindowRateLimiterOptions
            {
                AutoReplenishment = true,
                PermitLimit = 36,
                QueueLimit = 0,
                Window = TimeSpan.FromMinutes(1)
            }));
});

builder.Services.AddHostedService<ProcessTokenService>();
builder.Services.AddHostedService<StartupConfiguration>();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();
    app.MapScalarApiReference(options =>
        {
            options
                .WithTitle("Cortex Remote")
                .WithTheme(ScalarTheme.DeepSpace)
                .WithDefaultHttpClient(ScalarTarget.CSharp, ScalarClient.HttpClient);
        });
}

app.UseHttpsRedirection();

app.MapCommands()
    .RequireAuthorization();

app.MapAuthentication(rsa);

app.UseRateLimiter();

await app.RunAsync();