CLI Project w/ Authentication

src/dotnet/.gitignore

@@ -485,4 +485,6 @@ $RECYCLE.BIN/
 
 appsettings.*.json
 sharedsettings.*.json
-app.db
+app.db
+
+HQ.CLI/data/

src/dotnet/HQ.Abstractions/HQ.Abstractions.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

src/dotnet/HQ.Server/WeatherForecast.cs → src/dotnet/HQ.Abstractions/WeatherForecast.cs

@@ -1,4 +1,4 @@
-namespace HQ.Server;
+namespace HQ.Abstractions;
 
 public class WeatherForecast
 {

src/dotnet/HQ.CLI/Commands/ConfigureCommand.cs

@@ -0,0 +1,34 @@
+using Microsoft.Extensions.Logging;
+using Spectre.Console;
+using Spectre.Console.Cli;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HQ.CLI.Commands;
+
+internal class ConfigureCommand : AsyncCommand<HQCommandSettings>
+{
+    private readonly HQConfig _config;
+
+    public ConfigureCommand(HQConfig config)
+    {
+        _config = config;
+    }
+
+    public override async Task<int> ExecuteAsync(CommandContext context, HQCommandSettings settings)
+    {
+        _config.ApiUrl = AnsiConsole.Prompt(
+            new TextPrompt<Uri>("Enter API URL:")
+                .ValidationErrorMessage("[red]That's not a valid API URL[/]")
+                .Validate(uri => uri.IsAbsoluteUri));
+
+        _config.AuthUrl = AnsiConsole.Prompt(new TextPrompt<Uri>("Enter Auth URL:")
+                .ValidationErrorMessage("[red]That's not a valid Auth URL[/]")
+                .Validate(uri => uri.IsAbsoluteUri));
+
+        return 0;
+    }
+}

src/dotnet/HQ.CLI/Commands/LoginCommand.cs

@@ -0,0 +1,109 @@
+using IdentityModel.Client;
+using Microsoft.AspNetCore.DataProtection;
+using Microsoft.Extensions.Logging;
+using Spectre.Console;
+using Spectre.Console.Cli;
+using System.Diagnostics;
+using static IdentityModel.OidcConstants;
+
+namespace HQ.CLI.Commands;
+
+internal class LoginCommand : AsyncCommand<HQCommandSettings>
+{
+    private readonly ILogger<LoginCommand> _logger;
+    private readonly HQConfig _config;
+    private readonly IDataProtectionProvider _dataProtectionProvider;
+    private readonly HttpClient _httpClient;
+
+    public LoginCommand(ILogger<LoginCommand> logger, HQConfig config, IDataProtectionProvider dataProtectionProvider, HttpClient httpClient)
+    {
+        _logger = logger;
+        _config = config;
+        _dataProtectionProvider = dataProtectionProvider;
+        _httpClient = httpClient;
+    }
+
+    public override async Task<int> ExecuteAsync(CommandContext context, HQCommandSettings settings)
+    {
+        if(String.IsNullOrEmpty(_config.AuthUrl?.AbsoluteUri))
+        {
+            AnsiConsole.MarkupLine("[red]Invalid Auth URL[/]");
+            return 1;
+        }
+
+        var disco = await _httpClient.GetDiscoveryDocumentAsync(_config.AuthUrl.AbsoluteUri);
+        if (disco.IsError) throw new Exception(disco.Error);
+
+        var authorizeResponse = await _httpClient.RequestDeviceAuthorizationAsync(new DeviceAuthorizationRequest
+        {
+            Address = disco.DeviceAuthorizationEndpoint,
+            ClientId = "hq",
+            Scope = "openid profile email offline_access"
+        });
+        if (authorizeResponse.IsError) throw new Exception(authorizeResponse.Error);
+
+        AnsiConsole.MarkupLineInterpolated($@"Attempting to automatically open the login page in your default browser.
+If the browser does not open or you wish to use a different device to authorize this request, open the following URL:
+
+[link]{authorizeResponse.VerificationUri}[/]
+
+Then enter the code:
+
+{authorizeResponse.UserCode}");
+
+        try
+        {
+            Process launchBrowserProcess = new Process();
+            launchBrowserProcess.StartInfo.UseShellExecute = true;
+            launchBrowserProcess.StartInfo.FileName = authorizeResponse.VerificationUriComplete;
+            launchBrowserProcess.Start();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Unable to launch browser.");
+        }
+
+        var interval = TimeSpan.FromSeconds(authorizeResponse.Interval);
+        var expiresIn = authorizeResponse.ExpiresIn;
+        DateTime? expiresAt = null;
+        if (expiresIn.HasValue)
+        {
+            expiresAt = DateTime.UtcNow.AddSeconds(expiresIn.Value);
+        }
+
+        IdentityModel.Client.TokenResponse? response = null;
+        do
+        {
+            response = await _httpClient.RequestDeviceTokenAsync(new DeviceTokenRequest
+            {
+                Address = disco.TokenEndpoint,
+
+                ClientId = "hq",
+                DeviceCode = authorizeResponse.DeviceCode
+            });
+
+            // Console.WriteLine(response.Raw);
+
+            if (response.Error == "slow_down")
+            {
+                // Console.WriteLine("Got a slow down!");
+                interval += TimeSpan.FromSeconds(5);
+            }
+
+            // Console.WriteLine("Waiting for response...");
+            await Task.Delay(interval);
+        }
+        while (response.Error == "authorization_pending" || response.Error == "slow_down");
+        if (response.IsError) throw new Exception(response.Error);
+
+        var protector = _dataProtectionProvider.CreateProtector("HQ.CLI");
+
+        _config.RefreshToken = !String.IsNullOrEmpty(response.RefreshToken) ? protector.Protect(response.RefreshToken) : null;
+        _config.AccessToken = !String.IsNullOrEmpty(response.AccessToken) ? protector.Protect(response.AccessToken) : null; ;
+        _config.AccessTokenExpiresAt = DateTime.UtcNow.AddSeconds(response.ExpiresIn);
+
+        AnsiConsole.MarkupLine("[green]Authentication successful![/] ");
+
+        return 0;
+    }
+}

src/dotnet/HQ.CLI/Commands/TestApiCommand.cs

@@ -0,0 +1,28 @@
+using HQ.SDK;
+using Spectre.Console.Cli;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HQ.CLI.Commands
+{
+    internal class TestApiCommand : AsyncCommand<HQCommandSettings>
+    {
+        private readonly TestApiService _testApiService;
+
+        public TestApiCommand(TestApiService testApiService)
+        {
+            _testApiService = testApiService;
+        }
+
+        public override async Task<int> ExecuteAsync(CommandContext context, HQCommandSettings settings)
+        {
+            var response = await _testApiService.GetWeatherForecastAsync();
+            Console.WriteLine(response);
+
+            return 0;
+        }
+    }
+}

src/dotnet/HQ.CLI/HQ.CLI.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<OutputType>Exe</OutputType>
+		<TargetFramework>net8.0</TargetFramework>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+		<PublishSingleFile>true</PublishSingleFile>
+		<SelfContained>true</SelfContained>
+		<AssemblyName>hq</AssemblyName>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="IdentityModel" Version="6.2.0" />
+		<PackageReference Include="Microsoft.AspNetCore.DataProtection.Extensions" Version="8.0.3" />
+		<PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />
+		<PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />
+		<PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.0" />
+		<PackageReference Include="Spectre.Console.Cli" Version="0.48.1-preview.0.38" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<None Update="Properties\launchSettings.json">
+			<ExcludeFromSingleFile>true</ExcludeFromSingleFile>
+			<CopyToPublishDirectory>Never</CopyToPublishDirectory>
+		</None>
+	</ItemGroup>
+
+	<ItemGroup>
+	  <Folder Include="data\keys\" />
+	  <Folder Include="Settings\" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\HQ.SDK\HQ.SDK.csproj" />
+	</ItemGroup>
+
+</Project>

src/dotnet/HQ.CLI/HQApiMessageHandler.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http.Headers;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+using System.Net.Http;
+using Microsoft.AspNetCore.DataProtection;
+using IdentityModel.Client;
+using static IdentityModel.OidcConstants;
+
+namespace HQ.CLI
+{
+    internal class HQApiMessageHandler : DelegatingHandler
+    {
+        private readonly HQConfig _config;
+        private readonly HttpClient _httpClient;
+        private readonly IDataProtector _dataProtector;
+
+        public HQApiMessageHandler(HQConfig config, HttpClient httpClient, IDataProtectionProvider dataProtectionProvider)
+        {
+            _config = config;
+            _httpClient = httpClient;
+            _dataProtector = dataProtectionProvider.CreateProtector("HQ.CLI");
+        }
+
+        private async Task<string> GetTokenAsync(CancellationToken cancellationToken, bool forceRefresh = false)
+        {
+            var accessToken = _dataProtector.Unprotect(_config.AccessToken);
+            var refreshToken = _dataProtector.Unprotect(_config.RefreshToken);
+
+            if ((_config.AccessTokenExpiresAt.HasValue && _config.AccessTokenExpiresAt.Value <= DateTime.UtcNow) || forceRefresh)
+            {
+                var disco = await _httpClient.GetDiscoveryDocumentAsync(_config.AuthUrl.AbsoluteUri);
+                if (disco.IsError) throw new Exception(disco.Error);
+
+                var response = await _httpClient.RequestRefreshTokenAsync(new RefreshTokenRequest
+                {
+                    Address = disco.TokenEndpoint,
+
+                    ClientId = "hq",
+                    RefreshToken = refreshToken
+                });
+
+                if (response.IsError) throw new Exception(response.Error);
+
+                accessToken = response.AccessToken;
+
+                _config.RefreshToken = !String.IsNullOrEmpty(response.RefreshToken) ? _dataProtector.Protect(response.RefreshToken) : null;
+                _config.AccessToken = !String.IsNullOrEmpty(response.AccessToken) ? _dataProtector.Protect(response.AccessToken) : null; ;
+                _config.AccessTokenExpiresAt = DateTime.UtcNow.AddSeconds(response.ExpiresIn);
+            }
+
+            return accessToken;
+        }
+
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            var token = await GetTokenAsync(cancellationToken);
+            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
+
+            var response = await base.SendAsync(request, cancellationToken);
+            if (response.StatusCode == HttpStatusCode.Unauthorized)
+            {
+                token = await GetTokenAsync(cancellationToken, true);
+                request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
+                response.Dispose();
+
+                response = await base.SendAsync(request, cancellationToken);
+            }
+
+            return response;
+        }
+    }
+}

src/dotnet/HQ.CLI/HQCommandInterceptor.cs

@@ -0,0 +1,18 @@
+using Spectre.Console.Cli;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HQ.CLI;
+
+internal class HQCommandInterceptor : ICommandInterceptor
+{
+    public void Intercept(CommandContext context, CommandSettings settings)
+    {
+        if (settings is HQCommandSettings hqSettings)
+        {
+        }
+    }
+}

src/dotnet/HQ.CLI/HQCommandSettings.cs

@@ -0,0 +1,13 @@
+using Spectre.Console.Cli;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HQ.CLI
+{
+    public class HQCommandSettings : CommandSettings
+    {
+    }
+}

src/dotnet/HQ.CLI/HQConfig.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace HQ.CLI
+{
+    internal class HQConfig
+    {
+        public Uri? ApiUrl { get; set; }
+        public Uri? AuthUrl { get; set; }
+        public string? RefreshToken { get; set; }
+        public string? AccessToken { get; set; }
+        public DateTime? AccessTokenExpiresAt { get; set; }
+    }
+}