Add login command

Author: calebkiage

.vscode/launch.json

@@ -5,7 +5,7 @@
     "version": "0.2.0",
     "configurations": [
         {
-            "name": ".NET Core Launch (console)",
+            "name": "help",
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
@@ -15,6 +15,17 @@
             "console": "internalConsole",
             "stopAtEntry": false
         },
+        {
+            "name": "me get",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            "program": "${workspaceFolder}/src/bin/Debug/net6.0/msgraph-cli.dll",
+            "args": ["me", "get"],
+            "cwd": "${workspaceFolder}",
+            "console": "internalConsole",
+            "stopAtEntry": false
+        },
         {
             "name": ".NET Core Attach",
             "type": "coreclr",

src/Authentication/AuthenticationServiceFactory.cs

@@ -0,0 +1,61 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Azure.Core;
+using Azure.Identity;
+using Microsoft.Graph.Cli.Utils;
+
+namespace Microsoft.Graph.Cli.Authentication;
+
+class AuthenticationServiceFactory {
+    public async Task<IAuthenticationService> GetAuthenticationServiceAsync(AuthenticationStrategy strategy, bool persistToken = false) {
+        switch (strategy) {
+            case AuthenticationStrategy.DeviceCode:
+                return await GetDeviceCodeAuthenticationServiceAsync(persistToken);
+            default:
+                throw new InvalidOperationException($"The authentication strategy {strategy} is not supported");
+        }
+
+    }
+
+    public async Task<TokenCredential> GetTokenCredentialAsync(AuthenticationStrategy strategy, bool persistToken = false) {
+        switch (strategy) {
+            case AuthenticationStrategy.DeviceCode:
+                return await GetDeviceCodeCredentialAsync(persistToken);
+            default:
+                throw new InvalidOperationException($"The authentication strategy {strategy} is not supported");
+        }
+    }
+
+    private async Task<DeviceCodeAuthenticationService> GetDeviceCodeAuthenticationServiceAsync(bool persistToken = false) {
+        var credential = await GetDeviceCodeCredentialAsync(persistToken);
+        return new(credential);
+    }
+
+    private async Task<DeviceCodeCredential> GetDeviceCodeCredentialAsync(bool persistToken) {
+        DeviceCodeCredentialOptions credOptions = new()
+        {
+            ClientId = Constants.ClientId,
+            TenantId = Constants.TenantId
+        };
+
+        if (persistToken) {
+            TokenCachePersistenceOptions tokenCacheOptions = new() { Name = Constants.TokenCacheName };
+            credOptions.TokenCachePersistenceOptions = tokenCacheOptions;
+            var recordPath = Constants.AuthRecordPath;
+
+            if (File.Exists(recordPath))
+            {
+                using var authRecordStream = new FileStream(recordPath, FileMode.Open, FileAccess.Read);
+                var authRecord = await AuthenticationRecord.DeserializeAsync(authRecordStream);
+                credOptions.AuthenticationRecord = authRecord;
+            }
+        }
+
+        return new DeviceCodeCredential(credOptions);
+    }
+}
+
+enum AuthenticationStrategy {
+    DeviceCode
+}

src/Authentication/DeviceCodeAuthenticationService.cs

@@ -0,0 +1,22 @@
+using Azure.Core;
+using Azure.Identity;
+using Microsoft.Graph.Cli.Utils;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Microsoft.Graph.Cli.Authentication;
+
+class DeviceCodeAuthenticationService : IAuthenticationService {
+    private DeviceCodeCredential credential;
+
+    public DeviceCodeAuthenticationService(DeviceCodeCredential credential) {
+        this.credential = credential;
+    }
+
+    public async Task LoginAsync(string[] scopes) {
+        var authRecord = await credential.AuthenticateAsync(new TokenRequestContext(scopes));
+        // Serialize the AuthenticationRecord to disk so that it can be re-used across executions of this initialization code.
+        using var authRecordStream = new FileStream(Constants.AuthRecordPath, FileMode.OpenOrCreate, FileAccess.Write);
+        await authRecord.SerializeAsync(authRecordStream);
+    }
+}

src/Authentication/IAuthenticationService.cs

@@ -0,0 +1,7 @@
+using System.Threading.Tasks;
+
+namespace Microsoft.Graph.Cli.Authentication;
+
+interface IAuthenticationService {
+    Task LoginAsync(string[] scopes);
+}

src/Commands/Authentication/LoginCommand.cs

@@ -0,0 +1,28 @@
+using Microsoft.Graph.Cli.Authentication;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+
+namespace Microsoft.Graph.Cli.Commands.Authentication;
+
+class LoginCommand
+{
+    private IAuthenticationService authenticationService;
+
+    public LoginCommand(IAuthenticationService authenticationService) {
+        this.authenticationService = authenticationService;
+    }
+
+    public Command Build() {
+        var loginCommand = new Command("login", "Login and store the session for use in subsequent commands");
+        var scopes = new Option<string>("--scopes", "The login scopes e.g. User.Read");
+        scopes.IsRequired = true;
+        scopes.Arity = ArgumentArity.OneOrMore;
+        loginCommand.AddOption(scopes);
+        loginCommand.Handler = CommandHandler.Create<string[]>(async (scopes) =>
+        {
+            await this.authenticationService.LoginAsync(scopes);
+        });
+
+        return loginCommand;
+    }
+}

src/Program.cs

@@ -1,5 +1,7 @@
 using ApiSdk;
 using Azure.Identity;
+using Microsoft.Graph.Cli.Authentication;
+using Microsoft.Graph.Cli.Commands.Authentication;
 using Microsoft.Graph.Cli.Utils;
 using Microsoft.Kiota.Authentication.Azure;
 using Microsoft.Kiota.Http.HttpClientLibrary;
@@ -10,19 +12,21 @@ namespace Microsoft.Graph.Cli
 {
     class Program {
         static async Task<int> Main(string[] args) {
-            DeviceCodeCredentialOptions credOptions = new()
-            {
-                ClientId = Constants.ClientId,
-                TenantId = Constants.TenantId
-            };
+            var authServiceFactory = new AuthenticationServiceFactory();
+            var authStrategy = AuthenticationStrategy.DeviceCode;
+            var persistToken = true;
 
-            var credential = new DeviceCodeCredential(credOptions);
+            var credential = await authServiceFactory.GetTokenCredentialAsync(authStrategy, persistToken);
             var authProvider = new AzureIdentityAuthenticationProvider(credential);
             var core = new HttpClientRequestAdapter(authProvider);
             var client = new GraphClient(core);
 
             var rootCommand = client.BuildCommand();
             rootCommand.Description = "Microsoft Graph CLI";
+
+            var authenticationService = await authServiceFactory.GetAuthenticationServiceAsync(authStrategy, persistToken);
+            var loginCommand = new LoginCommand(authenticationService);
+            rootCommand.AddCommand(loginCommand.Build());
             return await rootCommand.InvokeAsync(args);
         }
     }

src/utils/Constants.cs

@@ -4,6 +4,8 @@ class Constants
     {
         public const string AuthRecordPath = "authRecord";
 
+        public const string TokenCacheName = "MicrosoftGraph";
+
         public const string ClientId = "f645f5f8-2332-496d-9d85-e714b1192f0c";
 
         public const string TenantId = "39aafea4-2975-4790-9c07-e616c1c35d99";