diff --git a/eng/Versions.MSIdentity.props b/eng/Versions.MSIdentity.props
index a6556fff4..1739cf428 100644
--- a/eng/Versions.MSIdentity.props
+++ b/eng/Versions.MSIdentity.props
@@ -6,7 +6,7 @@
     <UsingToolNetFrameworkReferenceAssemblies>true</UsingToolNetFrameworkReferenceAssemblies>
   </PropertyGroup>
   <PropertyGroup>
-    <VersionPrefix>2.0.0</VersionPrefix>
+    <VersionPrefix>2.0.1</VersionPrefix>
     <PreReleaseVersionLabel>rtm</PreReleaseVersionLabel>
     <IsServicingBuild Condition="'$(PreReleaseVersionLabel)' == 'servicing'">true</IsServicingBuild>
     <!--
diff --git a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/CodeReaderWriter/ProjectModifier.cs b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/CodeReaderWriter/ProjectModifier.cs
index 254d7f47f..e9fa5217c 100644
--- a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/CodeReaderWriter/ProjectModifier.cs
+++ b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/CodeReaderWriter/ProjectModifier.cs
@@ -50,8 +50,7 @@ public async Task AddAuthCodeAsync()
                 if (csProjFiles.Count() != 1)
                 {
                     var errorMsg = string.Format(Resources.ProjectPathError, _toolOptions.ProjectFilePath);
-                    _consoleLogger.LogJsonMessage(new JsonResponse(Commands.UPDATE_PROJECT_COMMAND, State.Fail, output: errorMsg));
-                    return;
+                    _consoleLogger.LogFailureAndExit(errorMsg);
                 }
                 
                 _toolOptions.ProjectFilePath = csProjFiles.First();
@@ -89,7 +88,7 @@ public async Task AddAuthCodeAsync()
                 await HandleCodeFileAsync(file, project, options, codeModifierConfig.Identifier);
             }
 
-            _consoleLogger.LogJsonMessage(new JsonResponse(Commands.UPDATE_PROJECT_COMMAND, State.Success, output: _output.ToString().TrimEnd()));
+            _consoleLogger.LogJsonMessage(State.Success, output: _output.ToString().TrimEnd());
         }
 
         internal static string GetCodeFileString(CodeFile file, string identifier) // todo make all code files strings
@@ -306,7 +305,7 @@ private async Task HandleCodeFileAsync(CodeFile file, CodeAnalysis.Project proje
                             break;
                     }
                     
-                    _output.Append(string.Format(Resources.ModifiedCodeFile, file.FileName));
+                    _output.AppendLine(string.Format(Resources.ModifiedCodeFile, file.FileName));
                 }
             }
             catch (Exception e)
diff --git a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/DeveloperCredentials/DeveloperCredentialsReader.cs b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/DeveloperCredentials/DeveloperCredentialsReader.cs
index e426ebd49..14693d742 100644
--- a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/DeveloperCredentials/DeveloperCredentialsReader.cs
+++ b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/DeveloperCredentials/DeveloperCredentialsReader.cs
@@ -1,13 +1,14 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
 using Azure.Core;
+using Microsoft.DotNet.MSIdentity.Shared;
 
 namespace Microsoft.DotNet.MSIdentity.DeveloperCredentials
 {
     public class DeveloperCredentialsReader
     {
-        public TokenCredential GetDeveloperCredentials(string? username, string? currentApplicationTenantId)
+        public TokenCredential GetDeveloperCredentials(string? username, string? currentApplicationTenantId, IConsoleLogger consoleLogger)
         {
 #if AzureSDK
             * Tried but does not work if another tenant than the home tenant id is specified
@@ -28,7 +29,8 @@ public TokenCredential GetDeveloperCredentials(string? username, string? current
 #endif
             TokenCredential tokenCredential = new MsalTokenCredential(
                 currentApplicationTenantId,
-                username);
+                username,
+                consoleLogger);
             return tokenCredential;
         }
     }
diff --git a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/DeveloperCredentials/MsalTokenCredential.cs b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/DeveloperCredentials/MsalTokenCredential.cs
index 5d36c0ee7..620ae32b8 100644
--- a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/DeveloperCredentials/MsalTokenCredential.cs
+++ b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/DeveloperCredentials/MsalTokenCredential.cs
@@ -1,15 +1,16 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-using Azure.Core;
-using Microsoft.Graph;
-using Microsoft.Identity.Client;
-using Microsoft.Identity.Client.Extensions.Msal;
 using System;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Azure.Core;
+using Microsoft.DotNet.MSIdentity.Properties;
+using Microsoft.DotNet.MSIdentity.Shared;
+using Microsoft.Identity.Client;
+using Microsoft.Identity.Client.Extensions.Msal;
 
 namespace Microsoft.DotNet.MSIdentity.DeveloperCredentials
 {
@@ -19,11 +20,17 @@ public class MsalTokenCredential : TokenCredential
         private const string RedirectUri = "http://localhost";
 #pragma warning restore S1075 // URIs should not be hardcoded
 
-        public MsalTokenCredential(string? tenantId, string? username, string instance = "https://login.microsoftonline.com")
+        private readonly IConsoleLogger _consoleLogger;
+
+        public MsalTokenCredential(
+            string? tenantId,
+            string? username,
+            IConsoleLogger consoleLogger)
         {
+            _consoleLogger = consoleLogger;
             TenantId = tenantId ?? "organizations"; // MSA-passthrough
             Username = username;
-            Instance = instance;
+            Instance = "https://login.microsoftonline.com";
         }
 
         private IPublicClientApplication? App { get; set; }
@@ -99,7 +106,10 @@ public override async ValueTask<AccessToken> GetTokenAsync(TokenRequestContext r
             {
                 if (account == null && !string.IsNullOrEmpty(Username))
                 {
-                    Console.WriteLine($"No valid tokens found in the cache.\nPlease sign-in to Visual Studio with this account:\n\n{Username}.\n\nAfter signing-in, re-run the tool.\n");
+                    _consoleLogger.LogFailureAndExit(
+                        $"No valid tokens found in the cache.\n" +
+                        $"Please sign-in to Visual Studio with this account: {Username}.\n\n" +
+                        $"After signing-in, re-run the tool.");
                 }
                 result = await app.AcquireTokenInteractive(requestContext.Scopes)
                     .WithAccount(account)
@@ -109,24 +119,30 @@ public override async ValueTask<AccessToken> GetTokenAsync(TokenRequestContext r
             }
             catch (MsalServiceException ex)
             {
+                // AAD error codes: https://learn.microsoft.com/en-us/azure/active-directory/develop/reference-aadsts-error-codes
                 if (ex.Message.Contains("AADSTS70002")) // "The client does not exist or is not enabled for consumers"
                 {
-                    Console.WriteLine("An Azure AD tenant, and a user in that tenant, " +
-                        "needs to be created for this account before an application can be created. See https://aka.ms/ms-identity-app/create-a-tenant. ");
-                    Environment.Exit(1); // we want to exit here because this is probably an MSA without an AAD tenant.
+                    // We want to exit here because this is probably an MSA without an AAD tenant.
+                    _consoleLogger.LogFailureAndExit(
+                        "An Azure AD tenant, and a user in that tenant, " +
+                        "needs to be created for this account before an application can be created. " +
+                        "See https://aka.ms/ms-identity-app/create-a-tenant. ");
                 }
 
-                Console.WriteLine("Error encountered with sign-in. See error message for details:\n{0} ",
-                    ex.Message);
-                Environment.Exit(1); // we want to exit here. Re-sign in will not resolve the issue.
+                // we want to exit here. Re-sign in will not resolve the issue.
+                _consoleLogger.LogFailureAndExit(string.Join(Environment.NewLine, Resources.SignInError, ex.Message));
             }
             catch (Exception ex)
             {
-                Console.WriteLine("Error encountered with sign-in. See error message for details:\n{0} ",
-                    ex.Message);
-                Environment.Exit(1);
+                _consoleLogger.LogFailureAndExit(string.Join(Environment.NewLine, Resources.SignInError, ex.Message));
             }
-            return new AccessToken(result.AccessToken, result.ExpiresOn);
+
+            if (result is null)
+            {
+                _consoleLogger.LogFailureAndExit(Resources.FailedToAcquireToken);
+            }
+
+            return new AccessToken(result!.AccessToken, result.ExpiresOn);
         }
     }
 }
diff --git a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/MicrosoftIdentityPlatform/MicrosoftIdentityPlatformApplicationManager.cs b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/MicrosoftIdentityPlatform/MicrosoftIdentityPlatformApplicationManager.cs
index 8c424b2e4..d27f07528 100644
--- a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/MicrosoftIdentityPlatform/MicrosoftIdentityPlatformApplicationManager.cs
+++ b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/MicrosoftIdentityPlatform/MicrosoftIdentityPlatformApplicationManager.cs
@@ -11,13 +11,14 @@
 using Microsoft.DotNet.MSIdentity.Properties;
 using Microsoft.DotNet.MSIdentity.Shared;
 using Microsoft.DotNet.MSIdentity.Tool;
+using Microsoft.DotNet.Scaffolding.Shared;
 using Microsoft.Graph;
 
 namespace Microsoft.DotNet.MSIdentity.MicrosoftIdentityPlatformApplication
 {
     public class MicrosoftIdentityPlatformApplicationManager
     {
-        private StringBuilder _output = new StringBuilder();
+        private readonly StringBuilder _output = new StringBuilder();
         const string MicrosoftGraphAppId = "00000003-0000-0000-c000-000000000000";
         const string ScopeType = "Scope";
         private const string DefaultCallbackPath = "signin-oidc";
@@ -27,109 +28,106 @@ public class MicrosoftIdentityPlatformApplicationManager
         internal async Task<ApplicationParameters?> CreateNewAppAsync(
             TokenCredential tokenCredential,
             ApplicationParameters applicationParameters,
-            IConsoleLogger consoleLogger,
-            string commandName)
+            IConsoleLogger consoleLogger)
         {
-            var graphServiceClient = GetGraphServiceClient(tokenCredential);
-
-            // Get the tenant
-            Organization? tenant = await GetTenant(graphServiceClient);
-            if (tenant != null && tenant.TenantType.Equals("AAD B2C", StringComparison.OrdinalIgnoreCase))
-            {
-                applicationParameters.IsB2C = true;
-            }
-            // Create the app.
-            Application application = new Application()
+            try
             {
-                DisplayName = applicationParameters.ApplicationDisplayName,
-                SignInAudience = AppParameterAudienceToMicrosoftIdentityPlatformAppAudience(applicationParameters.SignInAudience!),
-                Description = applicationParameters.Description
-            };
+                var graphServiceClient = GetGraphServiceClient(tokenCredential);
 
-            if (applicationParameters.IsWebApi.GetValueOrDefault())
-            {
-                application.Api = new ApiApplication()
+                // Get the tenant
+                Organization? tenant = await GetTenant(graphServiceClient, consoleLogger);
+                if (tenant != null && tenant.TenantType.Equals("AAD B2C", StringComparison.OrdinalIgnoreCase))
                 {
-                    RequestedAccessTokenVersion = 2,
+                    applicationParameters.IsB2C = true;
+                }
+                // Create the app.
+                Application application = new Application()
+                {
+                    DisplayName = applicationParameters.ApplicationDisplayName,
+                    SignInAudience = AppParameterAudienceToMicrosoftIdentityPlatformAppAudience(applicationParameters.SignInAudience!),
+                    Description = applicationParameters.Description
                 };
-            }
 
-            if (applicationParameters.IsWebApp.GetValueOrDefault())
-            {
-                AddWebAppPlatform(application, applicationParameters);
-            }
-            else if (applicationParameters.IsBlazorWasm)
-            {
-                AddSpaPlatform(application, applicationParameters.WebRedirectUris);
-            }
+                if (applicationParameters.IsWebApi.GetValueOrDefault())
+                {
+                    application.Api = new ApiApplication()
+                    {
+                        RequestedAccessTokenVersion = 2,
+                    };
+                }
 
-            var createdApplication = await graphServiceClient.Applications
-                .Request()
-                .AddAsync(application);
+                if (applicationParameters.IsWebApp.GetValueOrDefault())
+                {
+                    AddWebAppPlatform(application, applicationParameters);
+                }
+                else if (applicationParameters.IsBlazorWasm)
+                {
+                    AddSpaPlatform(application, applicationParameters.WebRedirectUris);
+                }
 
-            // Create service principal, necessary for Web API applications
-            // and useful for Blazorwasm hosted applications. We create it always.
-            ServicePrincipal servicePrincipal = new ServicePrincipal
-            {
-                AppId = createdApplication.AppId,
-            };
+                var createdApplication = await graphServiceClient.Applications
+                    .Request()
+                    .AddAsync(application);
 
-            ServicePrincipal? createdSp = await graphServiceClient.ServicePrincipals
-                .Request()
-                .AddAsync(servicePrincipal);
+                // Create service principal, necessary for Web API applications
+                // and useful for Blazorwasm hosted applications. We create it always.
+                var createdSp = await GetOrCreateSP(graphServiceClient, createdApplication.AppId, consoleLogger);
 
-            if (createdSp is null)
-            {
-                consoleLogger.LogJsonMessage(new JsonResponse(commandName, State.Fail, output: Resources.FailedToGetServicePrincipal));
-                return null;
-            }
+                // B2C does not allow user consent, and therefore we need to explicity grant permissions
+                if (applicationParameters.IsB2C)
+                {
+                    string scopes = GetMsGraphScopes(applicationParameters); // Explicit usage of MicrosoftGraph openid and offline_access in the case of Azure AD B2C.
+                    await AddDownstreamApiPermissions(scopes, graphServiceClient, application, createdSp);
+                }
 
-            // B2C does not allow user consent, and therefore we need to explicity grant permissions
-            if (applicationParameters.IsB2C) 
-            {
-                string scopes = GetMsGraphScopes(applicationParameters); // Explicit usage of MicrosoftGraph openid and offline_access in the case of Azure AD B2C.
-                await AddDownstreamApiPermissions(scopes, graphServiceClient, application, createdSp);
-            }
+                // For web API, we need to know the appId of the created app to compute the Identifier URI,
+                // and therefore we need to do it after the app is created (updating the app)
+                if (applicationParameters.IsWebApi.GetValueOrDefault() && createdApplication.Api != null)
+                {
+                    await ExposeWebApiScopes(graphServiceClient, createdApplication, applicationParameters);
 
-            // For web API, we need to know the appId of the created app to compute the Identifier URI,
-            // and therefore we need to do it after the app is created (updating the app)
-            if (applicationParameters.IsWebApi.GetValueOrDefault() && createdApplication.Api != null)
-            {
-                await ExposeWebApiScopes(graphServiceClient, createdApplication, applicationParameters);
+                    // Re-reading the app to be sure to have everything.
+                    createdApplication = (await graphServiceClient.Applications
+                        .Request()
+                        .Filter($"appId eq '{createdApplication.AppId}'")
+                        .GetAsync()).FirstOrDefault();
+                }
 
-                // Re-reading the app to be sure to have everything.
-                createdApplication = (await graphServiceClient.Applications
-                    .Request()
-                    .Filter($"appId eq '{createdApplication.AppId}'")
-                    .GetAsync()).FirstOrDefault();
-            }
+                // log json console message inside this method since we need the Microsoft.Graph.Application
+                if (createdApplication is null)
+                {
+                    consoleLogger.LogFailureAndExit(Resources.FailedToCreateApp);
+                    return null;
+                }
 
-            // log json console message inside this method since we need the Microsoft.Graph.Application
-            if (createdApplication is null)
-            {
-                consoleLogger.LogJsonMessage(new JsonResponse(commandName, State.Fail, output: Resources.FailedToCreateApp));
-                return null;
-            }
+                if (applicationParameters.IsB2C)
+                {
+                    createdApplication!.AdditionalData.Add("IsB2C", true);
+                }
 
-            if (applicationParameters.IsB2C)
-            {
-                createdApplication.AdditionalData.Add("IsB2C", true);
-            }
+                ApplicationParameters? effectiveApplicationParameters = GetEffectiveApplicationParameters(tenant!, createdApplication, applicationParameters);
 
-            ApplicationParameters? effectiveApplicationParameters = GetEffectiveApplicationParameters(tenant!, createdApplication, applicationParameters);
+                // Add password credentials
+                if (applicationParameters.CallsMicrosoftGraph || applicationParameters.CallsDownstreamApi)
+                {
+                    await AddPasswordCredentialsAsync(
+                        graphServiceClient,
+                        createdApplication.Id,
+                        effectiveApplicationParameters,
+                        consoleLogger);
+                }
+
+                var output = string.Format(Resources.CreatedAppRegistration, effectiveApplicationParameters.ApplicationDisplayName, effectiveApplicationParameters.ClientId);
+                consoleLogger.LogJsonMessage(State.Success, content: createdApplication, output: output);
 
-            // Add password credentials
-            if (applicationParameters.CallsMicrosoftGraph || applicationParameters.CallsDownstreamApi)
+                return effectiveApplicationParameters;
+            }
+            catch (Exception ex)
             {
-                await AddPasswordCredentialsAsync(
-                    graphServiceClient,
-                    createdApplication.Id,
-                    effectiveApplicationParameters,
-                    consoleLogger);
+                var errorMessage = string.IsNullOrEmpty(ex.Message) ? ex.ToString() : ex.Message;
+                consoleLogger.LogFailureAndExit(errorMessage);
+                return null;
             }
-
-            consoleLogger.LogJsonMessage(new JsonResponse(commandName, State.Success, createdApplication));
-            return effectiveApplicationParameters;
         }
 
         private static string GetMsGraphScopes(ApplicationParameters applicationParameters)
@@ -147,7 +145,7 @@ private static string GetMsGraphScopes(ApplicationParameters applicationParamete
             return apiScopes.Trim();
         }
 
-        private static async Task<Organization?> GetTenant(GraphServiceClient graphServiceClient)
+        private static async Task<Organization?> GetTenant(GraphServiceClient graphServiceClient, IConsoleLogger consoleLogger)
         {
             Organization? tenant = null;
             try
@@ -160,21 +158,19 @@ private static string GetMsGraphScopes(ApplicationParameters applicationParamete
             {
                 if (ex.InnerException != null)
                 {
-                    Console.WriteLine(ex.InnerException.Message);
+                    consoleLogger.LogFailureAndExit(ex.InnerException.Message);
                 }
                 else
                 {
                     if (ex.Message.Contains("User was not found") || ex.Message.Contains("not found in tenant"))
                     {
-                        Console.WriteLine("User was not found.\nUse both --tenant-id <tenant> --username <username@tenant>.\nAnd re-run the tool.");
+                        consoleLogger.LogFailureAndExit("User was not found.\nUse both --tenant-id <tenant> --username <username@tenant>.\nAnd re-run the tool.");
                     }
                     else
                     {
-                        Console.WriteLine(ex.Message);
+                        consoleLogger.LogFailureAndExit(ex.Message);
                     }
                 }
-
-                Environment.Exit(1);
             }
 
             return tenant;
@@ -189,38 +185,36 @@ private static string GetMsGraphScopes(ApplicationParameters applicationParamete
         /// <param name="toolOptions"></param>
         /// <param name="commandName"></param>
         /// <returns></returns>
-        internal async Task<JsonResponse> UpdateApplication(
+        internal async Task UpdateApplication(
             TokenCredential tokenCredential,
             ApplicationParameters? parameters,
             ProvisioningToolOptions toolOptions,
-            string commandName)
+            IConsoleLogger consoleLogger,
+            StringBuilder? output = null)
         {
             if (parameters is null)
             {
-                return new JsonResponse(commandName, State.Fail, output: string.Format(Resources.FailedToUpdateAppNull, nameof(ApplicationParameters)));
+                consoleLogger.LogFailureAndExit(string.Format(Resources.FailedToUpdateAppNull, nameof(ApplicationParameters)));
             }
 
             var graphServiceClient = GetGraphServiceClient(tokenCredential);
 
             var remoteApp = (await graphServiceClient.Applications.Request()
-                .Filter($"appId eq '{parameters.ClientId}'").GetAsync()).FirstOrDefault(app => app.AppId.Equals(parameters.ClientId));
+                .Filter($"appId eq '{parameters!.ClientId}'").GetAsync()).FirstOrDefault(app => app.AppId.Equals(parameters.ClientId));
 
             if (remoteApp is null)
             {
-                return new JsonResponse(commandName, State.Fail, output: string.Format(Resources.NotFound, parameters.ClientId));
+                consoleLogger.LogFailureAndExit(string.Format(Resources.NotFound, parameters.ClientId));
+                return;
             }
 
             (bool needsUpdates, Application appUpdates) = GetApplicationUpdates(remoteApp, toolOptions, parameters);
-            StringBuilder output = new StringBuilder();
+            output ??= new StringBuilder();
             // B2C does not allow user consent, and therefore we need to explicity grant permissions
             if (parameters.IsB2C && parameters.CallsDownstreamApi && !string.IsNullOrEmpty(toolOptions.ApiScopes))
             {
                 // TODO: Add if it's B2C, acquire or create the SUSI Policy
-                var servicePrincipal = await GetOrCreateSP(graphServiceClient, parameters.ClientId);
-                if (servicePrincipal is null)
-                {
-                    return new JsonResponse(commandName, State.Fail, output: Resources.FailedToGetServicePrincipal);
-                }
+                var servicePrincipal = await GetOrCreateSP(graphServiceClient, parameters.ClientId, consoleLogger);
 
                 await AddDownstreamApiPermissions(toolOptions.ApiScopes, graphServiceClient, appUpdates, servicePrincipal, output);
                 needsUpdates = true;
@@ -228,7 +222,8 @@ internal async Task<JsonResponse> UpdateApplication(
 
             if (!needsUpdates)
             {
-                return new JsonResponse(commandName, State.Success, output: string.Format(Resources.NoUpdateNecessary, remoteApp.DisplayName, remoteApp.AppId));
+                consoleLogger.LogJsonMessage(State.Success, output: string.Format(Resources.NoUpdateNecessary, remoteApp.DisplayName, remoteApp.AppId));
+                return;
             }
 
             try
@@ -236,12 +231,12 @@ internal async Task<JsonResponse> UpdateApplication(
                 // TODO: update other fields, see https://github.com/jmprieur/app-provisonning-tool/issues/10
                 var updatedApp = await graphServiceClient.Applications[remoteApp.Id].Request().UpdateAsync(appUpdates);
                 output.Append(string.Format(Resources.SuccessfullyUpdatedApp, remoteApp.DisplayName, remoteApp.AppId));
-                return new JsonResponse(commandName, State.Success, output.ToString());
+                consoleLogger.LogJsonMessage(State.Success, output: output.ToString());
             }
             catch (ServiceException se)
             {
                 output.Append(se.Error?.Message);
-                return new JsonResponse(commandName, State.Fail, output.ToString());
+                consoleLogger.LogFailureAndExit(output.ToString());
             }
         }
 
@@ -260,7 +255,7 @@ await AddAdminConsentToApiPermissions(
                 output);
         }
 
-        private static async Task<ServicePrincipal?> GetOrCreateSP(GraphServiceClient graphServiceClient, string? clientId)
+        private static async Task<ServicePrincipal> GetOrCreateSP(GraphServiceClient graphServiceClient, string? clientId, IConsoleLogger consoleLogger)
         {
             var servicePrincipal = (await graphServiceClient.ServicePrincipals
                                 .Request()
@@ -281,7 +276,12 @@ await AddAdminConsentToApiPermissions(
                     .AddAsync(sp);
             }
 
-            return servicePrincipal;
+            if (servicePrincipal is null)
+            {
+                consoleLogger.LogFailureAndExit(Resources.FailedToGetServicePrincipal);
+            }
+
+            return servicePrincipal!;
         }
 
         /// <summary>
@@ -810,7 +810,7 @@ internal GraphServiceClient GetGraphServiceClient(TokenCredential tokenCredentia
             }
 
             var graphServiceClient = GetGraphServiceClient(tokenCredential);
-            Organization? tenant = await GetTenant(graphServiceClient);
+            Organization? tenant = await GetTenant(graphServiceClient, consoleLogger);
             var application = await GetApplication(tokenCredential, applicationParameters);
             if (application is null)
             {
@@ -824,6 +824,11 @@ internal GraphServiceClient GetGraphServiceClient(TokenCredential tokenCredentia
                 application,
                 applicationParameters);
 
+            if (effectiveApplicationParameters is null)
+            {
+                consoleLogger.LogFailureAndExit(Resources.FailedToRetrieveApplicationParameters);
+            }
+
             return effectiveApplicationParameters;
         }
 
diff --git a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/MicrosoftIdentityPlatform/TokenCredentialAuthenticationProvider.cs b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/MicrosoftIdentityPlatform/TokenCredentialAuthenticationProvider.cs
index 3243830e7..27a244f0e 100644
--- a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/MicrosoftIdentityPlatform/TokenCredentialAuthenticationProvider.cs
+++ b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/MicrosoftIdentityPlatform/TokenCredentialAuthenticationProvider.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
 using Azure.Core;
@@ -31,7 +31,6 @@ public TokenCredentialAuthenticationProvider(
         public async Task AuthenticateRequestAsync(HttpRequestMessage request)
         {
             // Try with the Shared token cache credentials
-
             TokenRequestContext context = new TokenRequestContext(_initialScopes.ToArray());
             AccessToken token = await _tokenCredentials.GetTokenAsync(context, CancellationToken.None);
 
diff --git a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Properties/Resources.Designer.cs b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Properties/Resources.Designer.cs
index 30f7f7b58..b07820705 100644
--- a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Properties/Resources.Designer.cs
+++ b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Properties/Resources.Designer.cs
@@ -547,6 +547,15 @@ internal static string FailedClientSecretWithApp {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Failed to acquire a token..
+        /// </summary>
+        internal static string FailedToAcquireToken {
+            get {
+                return ResourceManager.GetString("FailedToAcquireToken", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Failed to create Azure AD/AD B2C app registration..
         /// </summary>
@@ -574,6 +583,15 @@ internal static string FailedToModifyCodeFile {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Failed to provision Client Application for Blazor WASM hosted project.
+        /// </summary>
+        internal static string FailedToProvisionClientApp {
+            get {
+                return ResourceManager.GetString("FailedToProvisionClientApp", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Failed to retrieve all Azure AD/AD B2C objects(apps/service principals.
         /// </summary>
@@ -583,6 +601,15 @@ internal static string FailedToRetrieveADObjectsError {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Failed to retrieve application parameters..
+        /// </summary>
+        internal static string FailedToRetrieveApplicationParameters {
+            get {
+                return ResourceManager.GetString("FailedToRetrieveApplicationParameters", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Failed to update Azure AD app registration {0} ({1}).
         /// </summary>
@@ -601,6 +628,15 @@ internal static string FailedToUpdateAppNull {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Failed to update client app program.cs file for Blazor WASM hosted project.
+        /// </summary>
+        internal static string FailedToUpdateClientAppCode {
+            get {
+                return ResourceManager.GetString("FailedToUpdateClientAppCode", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Initializing User Secrets . . ..
         /// </summary>
@@ -704,6 +740,15 @@ internal static string ResourceFileParseError {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Error encountered with sign-in. See error message for details:.
+        /// </summary>
+        internal static string SignInError {
+            get {
+                return ResourceManager.GetString("SignInError", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to SUCCESS.
         /// </summary>
diff --git a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Properties/Resources.resx b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Properties/Resources.resx
index 6b9559ae3..0dab9f7de 100644
--- a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Properties/Resources.resx
+++ b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Properties/Resources.resx
@@ -240,6 +240,9 @@
   <data name="FailedClientSecretWithApp" xml:space="preserve">
     <value>Failed to add client secret for Azure AD app : {0}({1})</value>
   </data>
+  <data name="FailedToAcquireToken" xml:space="preserve">
+    <value>Failed to acquire a token.</value>
+  </data>
   <data name="FailedToCreateApp" xml:space="preserve">
     <value>Failed to create Azure AD/AD B2C app registration.</value>
   </data>
@@ -250,9 +253,15 @@
     <value>Failed to modify code file {0}, {1} </value>
     <comment>0 = File name, 1 = Exception message</comment>
   </data>
+  <data name="FailedToProvisionClientApp" xml:space="preserve">
+    <value>Failed to provision Client Application for Blazor WASM hosted project</value>
+  </data>
   <data name="FailedToRetrieveADObjectsError" xml:space="preserve">
     <value>Failed to retrieve all Azure AD/AD B2C objects(apps/service principals</value>
   </data>
+  <data name="FailedToRetrieveApplicationParameters" xml:space="preserve">
+    <value>Failed to retrieve application parameters.</value>
+  </data>
   <data name="FailedToUpdateApp" xml:space="preserve">
     <value>Failed to update Azure AD app registration {0} ({1})</value>
     <comment>0 = Display Name, 1 = App Id</comment>
@@ -261,6 +270,9 @@
     <value>Failed to update Azure AD app, null {0}</value>
     <comment>0 = null object</comment>
   </data>
+  <data name="FailedToUpdateClientAppCode" xml:space="preserve">
+    <value>Failed to update client app program.cs file for Blazor WASM hosted project</value>
+  </data>
   <data name="InitializeUserSecrets" xml:space="preserve">
     <value>Initializing User Secrets . . .</value>
   </data>
@@ -301,6 +313,9 @@
     <value>Resource file {0} could not be parsed.</value>
     <comment>0 = CodeModifierConfigPropertyInfo.Name</comment>
   </data>
+  <data name="SignInError" xml:space="preserve">
+    <value>Error encountered with sign-in. See error message for details:</value>
+  </data>
   <data name="Success" xml:space="preserve">
     <value>SUCCESS</value>
   </data>
diff --git a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/AppProvisioningTool.cs b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/AppProvisioningTool.cs
index de3fbbe07..12b6f6add 100644
--- a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/AppProvisioningTool.cs
+++ b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/AppProvisioningTool.cs
@@ -18,6 +18,7 @@
 using Microsoft.DotNet.MSIdentity.Shared;
 using Microsoft.DotNet.MSIdentity.Tool;
 using Microsoft.Graph;
+using ConsoleLogger = Microsoft.DotNet.MSIdentity.Shared.ConsoleLogger;
 using Directory = System.IO.Directory;
 using ProjectDescription = Microsoft.DotNet.MSIdentity.Project.ProjectDescription;
 
@@ -45,25 +46,21 @@ public AppProvisioningTool(string commandName, ProvisioningToolOptions provision
         {
             CommandName = commandName;
             ProvisioningToolOptions = provisioningToolOptions;
-            ConsoleLogger = new ConsoleLogger(ProvisioningToolOptions.Json, silent);
+            ConsoleLogger = new ConsoleLogger(CommandName, ProvisioningToolOptions.Json, silent);
         }
 
         public async Task<ApplicationParameters?> Run()
         {
-            if (!ValidateProjectPath())
-            {
-                Environment.Exit(1);
-            }
+            ValidateProjectPath();
 
             var projectDescription = ProjectDescriptionReader.GetProjectDescription(ProvisioningToolOptions.ProjectTypeIdentifier);
             if (projectDescription == null)
             {
                 var errorMessage = string.Format(Resources.NoProjectDescriptionFound, ProvisioningToolOptions.ProjectTypeIdentifier);
-                ConsoleLogger.LogJsonMessage(new JsonResponse(CommandName, State.Fail, output: errorMessage));
-                Environment.Exit(1);
+                ConsoleLogger.LogFailureAndExit(errorMessage);
             }
 
-            ConsoleLogger.LogMessage(string.Format(Resources.DetectedProjectType, projectDescription.Identifier));
+            ConsoleLogger.LogMessage(string.Format(Resources.DetectedProjectType, projectDescription!.Identifier));
             ProvisioningToolOptions.ProjectType ??= projectDescription.Identifier?.Replace("dotnet-", "");
 
             ProjectAuthenticationSettings projectSettings = InferApplicationParameters(
@@ -74,7 +71,8 @@ public AppProvisioningTool(string commandName, ProvisioningToolOptions provision
             // Get developer credentials
             TokenCredential tokenCredential = GetTokenCredential(
                 ProvisioningToolOptions,
-                ProvisioningToolOptions.TenantId ?? projectSettings.ApplicationParameters.EffectiveTenantId ?? projectSettings.ApplicationParameters.EffectiveDomain);
+                ProvisioningToolOptions.TenantId ?? projectSettings.ApplicationParameters.EffectiveTenantId ?? projectSettings.ApplicationParameters.EffectiveDomain,
+                ConsoleLogger);
 
             ApplicationParameters applicationParameters;
             switch (CommandName)
@@ -155,14 +153,15 @@ await WriteApplicationRegistration(
         }
 
         /// <summary>
-        /// Ensures that ProjectPath is updated if ProjectFilePath argument exists
+        /// Ensures that ProjectPath is updated if ProjectFilePath argument exists,
+        /// logs failure and exits if ProjectFilePath cannot be determined
         /// </summary>
-        /// <returns>true if valid else false</returns>
-        private bool ValidateProjectPath()
+        /// <returns></returns>
+        private void ValidateProjectPath()
         {
             if (string.IsNullOrEmpty(ProvisioningToolOptions.ProjectFilePath))
             {
-                return true;
+                return;
             }
 
             if (System.IO.File.Exists(ProvisioningToolOptions.ProjectFilePath)
@@ -173,12 +172,11 @@ private bool ValidateProjectPath()
                     ProvisioningToolOptions.ProjectPath = projectPath;
                 }
 
-                return true;
+                return;
             }
 
             var errorMsg = string.Format(Resources.ProjectPathError, ProvisioningToolOptions.ProjectFilePath);
-            ConsoleLogger.LogJsonMessage(new JsonResponse(CommandName, State.Fail, output: errorMsg));
-            return false;
+            ConsoleLogger.LogFailureAndExit(errorMsg);
         }
 
         private ProjectAuthenticationSettings InferApplicationParameters(
@@ -230,12 +228,13 @@ private ProjectAuthenticationSettings InferApplicationParameters(
         /// <param name="provisioningToolOptions"></param>
         /// <param name="currentApplicationTenantId"></param>
         /// <returns></returns>
-        internal static TokenCredential GetTokenCredential(ProvisioningToolOptions provisioningToolOptions, string? currentApplicationTenantId)
+        internal static TokenCredential GetTokenCredential(ProvisioningToolOptions provisioningToolOptions, string? currentApplicationTenantId, IConsoleLogger consoleLogger)
         {
             DeveloperCredentialsReader developerCredentialsReader = new DeveloperCredentialsReader();
             return developerCredentialsReader.GetDeveloperCredentials(
                 provisioningToolOptions.Username,
-                currentApplicationTenantId ?? provisioningToolOptions.TenantId);
+                currentApplicationTenantId ?? provisioningToolOptions.TenantId,
+                consoleLogger);
         }
 
         /// <summary>
@@ -246,15 +245,12 @@ internal static TokenCredential GetTokenCredential(ProvisioningToolOptions provi
         /// <returns></returns>
         private async Task<ApplicationParameters?> CreateAppRegistration(TokenCredential tokenCredential, ApplicationParameters applicationParameters)
         {
-            ApplicationParameters? resultAppParameters = await MicrosoftIdentityPlatformApplicationManager.CreateNewAppAsync(tokenCredential, applicationParameters, ConsoleLogger, CommandName);
+            ApplicationParameters? resultAppParameters = await MicrosoftIdentityPlatformApplicationManager.CreateNewAppAsync(tokenCredential, applicationParameters, ConsoleLogger);
             if (resultAppParameters is null || string.IsNullOrEmpty(resultAppParameters.ClientId))
             {
-                string failMessage = Resources.FailedToCreateApp;
-                ConsoleLogger.LogMessage(failMessage, LogMessageType.Error);
-                return null;
+                ConsoleLogger.LogFailureAndExit(Resources.FailedToCreateApp);
             }
 
-            ConsoleLogger.LogMessage(string.Format(Resources.CreatedAppRegistration, resultAppParameters.ApplicationDisplayName, resultAppParameters.ClientId));
             return resultAppParameters;
         }
 
@@ -269,12 +265,8 @@ private async Task<ApplicationParameters> ReadMicrosoftIdentityApplication(
             ApplicationParameters applicationParameters)
         {
             var currentApplicationParameters = await MicrosoftIdentityPlatformApplicationManager.ReadApplication(tokenCredential, applicationParameters, ConsoleLogger);
-            if (currentApplicationParameters is null)
-            {
-                Environment.Exit(1);
-            }
 
-            return currentApplicationParameters;
+            return currentApplicationParameters!;
         }
 
         /// <summary>
@@ -296,19 +288,22 @@ private async Task UpdateAppRegistration(TokenCredential tokenCredential, Applic
                 }
 
                 var clientApplicationParameters = await ConfigureBlazorWasmHostedClientAsync(serverApplicationParameters: applicationParameters);
+                if (clientApplicationParameters is null)
+                {
+                    ConsoleLogger.LogFailureAndExit("Failed to provision Blazor Wasm hosted scenario"); // TODO string
+                    return;
+                }
+
                 ProvisioningToolOptions.BlazorWasmClientAppId = clientApplicationParameters.ClientId;
                 output.AppendLine(string.Format(Resources.ConfiguredBlazorWasmClient, clientApplicationParameters.ApplicationDisplayName, clientApplicationParameters.ClientId));
             }
 
-            var jsonResponse = await MicrosoftIdentityPlatformApplicationManager.UpdateApplication(
+            await MicrosoftIdentityPlatformApplicationManager.UpdateApplication(
                                         tokenCredential,
                                         applicationParameters,
                                         ProvisioningToolOptions,
-                                        CommandName);
-
-            output.Append(jsonResponse.Output);
-
-            ConsoleLogger.LogJsonMessage(new JsonResponse(CommandName, jsonResponse.State, output: output.ToString()));
+                                        ConsoleLogger,
+                                        output);
         }
 
         /// <summary>
@@ -317,7 +312,7 @@ private async Task UpdateAppRegistration(TokenCredential tokenCredential, Applic
         /// <param name="serverApplicationParameters"></param>
         /// <returns></returns>
         /// <exception cref="ArgumentNullException"></exception>
-        private async Task<ApplicationParameters> ConfigureBlazorWasmHostedClientAsync(ApplicationParameters serverApplicationParameters)
+        private async Task<ApplicationParameters?> ConfigureBlazorWasmHostedClientAsync(ApplicationParameters serverApplicationParameters)
         {
             // Processes the Blazorwasm client
             var clientToolOptions = ProvisioningToolOptions.Clone();
@@ -337,22 +332,16 @@ private async Task<ApplicationParameters> ConfigureBlazorWasmHostedClientAsync(A
             var clientApplicationParameters = await provisionClientAppRegistration.Run();
             if (clientApplicationParameters == null)
             {
-                var exception = new ArgumentNullException(nameof(clientApplicationParameters));
-
-                ConsoleLogger.LogJsonMessage(new JsonResponse(CommandName, State.Fail, output: exception.Message));
-                throw exception;
+                ConsoleLogger.LogFailureAndExit(Resources.FailedToProvisionClientApp);
             }
 
             // Update program.cs file
-            clientToolOptions.ClientId = clientApplicationParameters.ClientId;
+            clientToolOptions.ClientId = clientApplicationParameters!.ClientId;
             var updateCode = new AppProvisioningTool(Commands.UPDATE_PROJECT_COMMAND, clientToolOptions, silent: true);
             clientApplicationParameters = await updateCode.Run();
             if (clientApplicationParameters == null)
             {
-                var exception = new ArgumentNullException(nameof(clientApplicationParameters));
-
-                ConsoleLogger.LogJsonMessage(new JsonResponse(CommandName, State.Fail, output: exception.Message));
-                throw exception;
+                ConsoleLogger.LogFailureAndExit(Resources.FailedToUpdateClientAppCode);
             }
 
             return clientApplicationParameters;
@@ -472,12 +461,10 @@ await MicrosoftIdentityPlatformApplicationManager.AddPasswordCredentialsAsync(
         private async Task AddClientSecret(TokenCredential tokenCredential, ApplicationParameters applicationParameters)
         {
             string? output;
-            JsonResponse jsonResponse = new JsonResponse(CommandName);
 
             if (string.IsNullOrEmpty(applicationParameters.GraphEntityId))
             {
-                jsonResponse.State = State.Fail;
-                jsonResponse.Output = Resources.FailedClientSecret;
+                ConsoleLogger.LogFailureAndExit(Resources.FailedClientSecret);
             }
             else
             {
@@ -498,25 +485,18 @@ private async Task AddClientSecret(TokenCredential tokenCredential, ApplicationP
 
                     if (!string.IsNullOrEmpty(password))
                     {
-                        output = string.Format(Resources.ClientSecret, password);
-                        jsonResponse.State = State.Success;
-                        jsonResponse.Content = new KeyValuePair<string, string>("ClientSecret", password);
+                        ConsoleLogger.LogJsonMessage(State.Success, content: new KeyValuePair<string, string>("ClientSecret", password));
                     }
                     else
                     {
                         output = string.Format(Resources.FailedClientSecretWithApp, applicationParameters.ApplicationDisplayName, applicationParameters.ClientId);
-                        jsonResponse.State = State.Fail;
-                        jsonResponse.Content = "TODO Empty password";
+                        ConsoleLogger.LogFailureAndExit(output);
                     }
                 }
                 catch (ServiceException se)
                 {
-                    output = se.Error?.ToString();
-                    jsonResponse.State = State.Fail;
-                    jsonResponse.Output = se.Error?.Code; // TODO refactor
+                    ConsoleLogger.LogFailureAndExit(se.Error?.Code);
                 }
-
-                ConsoleLogger.LogJsonMessage(jsonResponse);
             }
         }
 
@@ -529,20 +509,15 @@ private async Task AddClientSecret(TokenCredential tokenCredential, ApplicationP
         private async Task UnregisterApplication(TokenCredential tokenCredential, ApplicationParameters applicationParameters)
         {
             bool unregisterSuccess = await MicrosoftIdentityPlatformApplicationManager.UnregisterAsync(tokenCredential, applicationParameters);
-            JsonResponse jsonResponse = new JsonResponse(CommandName);
             if (unregisterSuccess)
             {
                 string outputMessage = $"Unregistered the Azure AD w/ client id = {applicationParameters.ClientId}\n";
-                jsonResponse.State = State.Success;
-                jsonResponse.Output = outputMessage;
-                ConsoleLogger.LogJsonMessage(jsonResponse);
+                ConsoleLogger.LogJsonMessage(State.Success, output: outputMessage);
             }
             else
             {
                 string outputMessage = $"Unable to unregister the Azure AD w/ client id = {applicationParameters.ClientId}\n";
-                jsonResponse.State = State.Fail;
-                jsonResponse.Output = outputMessage;
-                ConsoleLogger.LogJsonMessage(jsonResponse);
+                ConsoleLogger.LogFailureAndExit(outputMessage);
             }
         }
 
@@ -615,7 +590,7 @@ private void WriteSummary(Summary summary)
         private async Task WriteApplicationRegistration(Summary summary, ApplicationParameters reconcialedApplicationParameters, TokenCredential tokenCredential)
         {
             summary.changes.Add(new Change($"Writing the project AppId = {reconcialedApplicationParameters.ClientId}"));
-            await MicrosoftIdentityPlatformApplicationManager.UpdateApplication(tokenCredential, reconcialedApplicationParameters, ProvisioningToolOptions, CommandName);
+            await MicrosoftIdentityPlatformApplicationManager.UpdateApplication(tokenCredential, reconcialedApplicationParameters, ProvisioningToolOptions, ConsoleLogger);
         }
 
         /// <summary>
@@ -677,7 +652,7 @@ private bool Reconciliate(ApplicationParameters applicationParameters, Applicati
 
             if (currentApplicationParameters == null && !ProvisioningToolOptions.Unregister)
             {
-                currentApplicationParameters = await MicrosoftIdentityPlatformApplicationManager.CreateNewAppAsync(tokenCredential, applicationParameters, ConsoleLogger, CommandName);
+                currentApplicationParameters = await MicrosoftIdentityPlatformApplicationManager.CreateNewAppAsync(tokenCredential, applicationParameters, ConsoleLogger);
                 if (currentApplicationParameters != null)
                 {
                     ConsoleLogger.LogMessage($"Created app {currentApplicationParameters.ApplicationDisplayName} - {currentApplicationParameters.ClientId}. ");
diff --git a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/GraphObjectRetriever.cs b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/GraphObjectRetriever.cs
new file mode 100644
index 000000000..2cd3380d4
--- /dev/null
+++ b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/GraphObjectRetriever.cs
@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.DotNet.MSIdentity.Properties;
+using Microsoft.DotNet.MSIdentity.Shared;
+using Microsoft.Graph;
+
+namespace Microsoft.DotNet.MSIdentity.Tool
+{
+    public interface IGraphObjectRetriever
+    {
+        /// <summary>
+        /// Requests all directory objects from the graph service client for the given account
+        /// </summary>
+        /// <returns></returns>
+        public Task<List<DirectoryObject>?> GetGraphObjects();
+
+        /// <summary>
+        /// Retrieves the Tenant object associated with the GraphServiceClient
+        /// </summary>
+        /// <returns></returns>
+        public Task<Organization?> GetTenant();
+    }
+
+    public class GraphObjectRetriever : IGraphObjectRetriever
+    {
+        private readonly GraphServiceClient _graphServiceClient;
+        private readonly IConsoleLogger _consoleLogger;
+
+        public GraphObjectRetriever(GraphServiceClient graphServiceClient, IConsoleLogger consoleLogger)
+        {
+            _graphServiceClient = graphServiceClient;
+            _consoleLogger = consoleLogger;
+        }
+
+        public async Task<List<DirectoryObject>?> GetGraphObjects()
+        {
+            List<DirectoryObject> graphObjectsList = new List<DirectoryObject>();
+            try
+            {
+                var graphObjects = await _graphServiceClient.Me.OwnedObjects
+                    .Request()
+                    .GetAsync();
+
+                if (graphObjects != null)
+                {
+                    graphObjectsList.AddRange(graphObjects.ToList());
+
+                    var nextPage = graphObjects.NextPageRequest;
+                    while (nextPage != null)
+                    {
+                        try
+                        {
+                            var additionalGraphObjects = await nextPage.GetAsync();
+                            if (additionalGraphObjects != null)
+                            {
+                                graphObjectsList.AddRange(additionalGraphObjects.ToList());
+                                nextPage = additionalGraphObjects.NextPageRequest;
+                            }
+                            else
+                            {
+                                nextPage = null;
+                            }
+                        }
+                        catch (ServiceException)
+                        {
+                            nextPage = null;
+                            _consoleLogger.LogFailureAndExit(Resources.FailedToRetrieveADObjectsError);
+                        }
+                    }
+                }
+            }
+            catch (ServiceException)
+            {
+                _consoleLogger.LogFailureAndExit(Resources.FailedToRetrieveADObjectsError);
+            }
+
+            return graphObjectsList;
+        }
+
+        public async Task<Organization?> GetTenant()
+        {
+            Organization? tenant;
+            try
+            {
+                tenant = (await _graphServiceClient.Organization
+                    .Request()
+                    .GetAsync()).FirstOrDefault();
+
+                return tenant;
+            }
+            catch (ServiceException ex)
+            {
+                string? errorMessage;
+                if (ex.InnerException != null)
+                {
+                    errorMessage = ex.InnerException.Message;
+                }
+                else
+                {
+                    if (ex.Message.Contains("User was not found") || ex.Message.Contains("not found in tenant"))
+                    {
+                        errorMessage = "User was not found.\nUse both --tenant-id <tenant> --username <username@tenant>.\nAnd re-run the tool.";
+                    }
+                    else
+                    {
+                        errorMessage = ex.Message;
+                    }
+                }
+
+                _consoleLogger.LogFailureAndExit(errorMessage);
+                return null;
+            }
+        }
+    }
+}
diff --git a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/MsAADTool.cs b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/MsAADTool.cs
index 8066ef003..9766c1ec7 100644
--- a/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/MsAADTool.cs
+++ b/src/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity/Tool/MsAADTool.cs
@@ -20,25 +20,27 @@ internal class MsAADTool : IMsAADTool
         private ProvisioningToolOptions ProvisioningToolOptions { get; set; }
         private string CommandName { get; }
         public GraphServiceClient GraphServiceClient { get; set; }
-        public IAzureManagementAuthenticationProvider AzureManagementAPI { get; set;}
+        public IAzureManagementAuthenticationProvider AzureManagementAPI { get; set; }
+        public IGraphObjectRetriever GraphObjectRetriever { get; set; }
         private MsalTokenCredential TokenCredential { get; set; }
 
         public MsAADTool(string commandName, ProvisioningToolOptions provisioningToolOptions)
         {
             ProvisioningToolOptions = provisioningToolOptions;
             CommandName = commandName;
-            TokenCredential = new MsalTokenCredential(ProvisioningToolOptions.TenantId, ProvisioningToolOptions.Username);
+            ConsoleLogger = new ConsoleLogger(CommandName, ProvisioningToolOptions.Json);
+            TokenCredential = new MsalTokenCredential(ProvisioningToolOptions.TenantId, ProvisioningToolOptions.Username, ConsoleLogger);
             GraphServiceClient = new GraphServiceClient(new TokenCredentialAuthenticationProvider(TokenCredential));
             AzureManagementAPI = new AzureManagementAuthenticationProvider(TokenCredential);
-            ConsoleLogger = new ConsoleLogger(ProvisioningToolOptions.Json);
+            GraphObjectRetriever = new GraphObjectRetriever(GraphServiceClient, ConsoleLogger);
         }
 
         public async Task<ApplicationParameters?> Run()
         {
-            string outputJsonString = string.Empty;    
+            string outputJsonString = string.Empty;
             if (TokenCredential != null && GraphServiceClient != null)
             {
-                switch(CommandName)
+                switch (CommandName)
                 {
                     //--list-aad-apps
                     case Commands.LIST_AAD_APPS_COMMAND:
@@ -63,140 +65,68 @@ public MsAADTool(string commandName, ProvisioningToolOptions provisioningToolOpt
             return null;
         }
 
-        private async Task<List<DirectoryObject>> GetGraphObjects()
-        {
-            List<DirectoryObject> graphObjectsList = new List<DirectoryObject>();
-            try
-            {
-                var graphObjects = await GraphServiceClient.Me.OwnedObjects
-                .Request()
-                .GetAsync();
-
-                if (graphObjects != null)
-                {
-                    graphObjectsList.AddRange(graphObjects.ToList());
-
-                    var nextPage = graphObjects.NextPageRequest;
-                    while (nextPage != null)
-                    {
-                        try
-                        {
-                            var additionalGraphObjects = await nextPage.GetAsync();
-                            if (additionalGraphObjects != null)
-                            {
-                                graphObjectsList.AddRange(additionalGraphObjects.ToList());
-                                nextPage = additionalGraphObjects.NextPageRequest;
-                            }
-                            else
-                            {
-                                nextPage = null;
-                            }
-                        }
-                        catch (ServiceException)
-                        {
-                            nextPage = null;
-                            ConsoleLogger.LogMessage(Resources.FailedToRetrieveADObjectsError, LogMessageType.Error);
-                        }
-                    }
-                }
-            }
-            catch (ServiceException)
-            {
-                ConsoleLogger.LogMessage(Resources.FailedToRetrieveADObjectsError, LogMessageType.Error);
-            }
-
-            return graphObjectsList;
-        }
-
         internal async Task<string> PrintApplicationsList()
         {
             string outputJsonString = string.Empty;
-            var graphObjectsList = await GetGraphObjects();
-            IList<Application> applicationList = new List<Application>();
-            if (graphObjectsList != null && graphObjectsList.Any())
+            var applications = await GetApplicationsAsync();
+            if (ProvisioningToolOptions.Json)
             {
-                foreach (var graphObj in graphObjectsList)
-                {
-                    if (graphObj is Application app)
-                    {
-                        applicationList.Add(app);
-                    }
-                }
-
-                if (applicationList.Any())
+                outputJsonString = new JsonResponse(CommandName, State.Success, applications).ToJsonString();
+            }
+            else
+            {
+                Console.Write(
+                    "--------------------------------------------------------------\n" +
+                    "Application Name\t\t\t\tApplication ID\n" +
+                    "--------------------------------------------------------------\n\n");
+                foreach (var app in applications)
                 {
-                    Organization? tenant = await GetTenant(GraphServiceClient);
-                    if (tenant != null && tenant.TenantType.Equals("AAD B2C", StringComparison.OrdinalIgnoreCase))
-                    {
-                        foreach (Application app in applicationList)
-                        {
-                            app.AdditionalData.Add("IsB2C", true);
-                        }
-                    }
-
-                    //order list by created date.
-                    applicationList = applicationList.OrderByDescending(app => app.CreatedDateTime).ToList();
-
-                    if (ProvisioningToolOptions.Json)
-                    {
-                        JsonResponse jsonResponse = new JsonResponse(CommandName, State.Success, applicationList);
-                        outputJsonString = jsonResponse.ToJsonString();
-                    }
-                    else
-                    {
-                        Console.Write(
-                            "--------------------------------------------------------------\n" +
-                            "Application Name\t\t\t\tApplication ID\n" +
-                            "--------------------------------------------------------------\n\n");
-                        foreach (var app in applicationList)
-                        {
-                            Console.WriteLine($"{app.DisplayName.PadRight(35)}\t\t{app.AppId}");
-                        }
-                    }
+                    Console.WriteLine($"{app.DisplayName,-35}\t\t{app.AppId}");
                 }
             }
 
             return outputJsonString;
         }
 
-        private static async Task<Organization?> GetTenant(GraphServiceClient graphServiceClient)
+        internal async Task<IList<Application>> GetApplicationsAsync()
         {
-            Organization? tenant = null;
-            try
+            var graphObjectsList = await GraphObjectRetriever.GetGraphObjects();
+            if (graphObjectsList is null)
             {
-                tenant = (await graphServiceClient.Organization
-                    .Request()
-                    .GetAsync()).FirstOrDefault();
+                ConsoleLogger.LogFailureAndExit(Resources.FailedToRetrieveADObjectsError);
             }
-            catch (ServiceException ex)
+
+            IList<Application> applicationList = new List<Application>();
+            foreach (var graphObj in graphObjectsList!)
             {
-                if (ex.InnerException != null)
+                if (graphObj is Application app)
                 {
-                    Console.WriteLine(ex.InnerException.Message);
+                    applicationList.Add(app);
                 }
-                else
+            }
+
+            if (applicationList.Any())
+            {
+                var tenant = await GraphObjectRetriever.GetTenant();
+                if (tenant != null && tenant.TenantType.Equals("AAD B2C", StringComparison.OrdinalIgnoreCase))
                 {
-                    if (ex.Message.Contains("User was not found") || ex.Message.Contains("not found in tenant"))
-                    {
-                        Console.WriteLine("User was not found.\nUse both --tenant-id <tenant> --username <username@tenant>.\nAnd re-run the tool.");
-                    }
-                    else
+                    foreach (var app in applicationList)
                     {
-                        Console.WriteLine(ex.Message);
+                        app.AdditionalData.Add("IsB2C", true);
                     }
                 }
 
-                Environment.Exit(1);
+                //order list by created date.
+                applicationList = applicationList.OrderByDescending(app => app.CreatedDateTime).ToList();
             }
 
-            return tenant;
+            return applicationList;
         }
 
-
         internal async Task<string> PrintServicePrincipalList()
         {
             string outputJsonString = string.Empty;
-            var graphObjectsList = await GetGraphObjects();
+            var graphObjectsList = await GraphObjectRetriever.GetGraphObjects();
             IList<ServicePrincipal> servicePrincipalList = new List<ServicePrincipal>();
 
             if (graphObjectsList != null && graphObjectsList.Any())
@@ -223,7 +153,7 @@ internal async Task<string> PrintServicePrincipalList()
                             "--------------------------------------------------------------\n\n");
                         foreach (var sp in servicePrincipalList)
                         {
-                            Console.WriteLine($"{sp.DisplayName.PadRight(35)}\t\t{sp.AppId}");
+                            Console.WriteLine($"{sp.DisplayName,-35}\t\t{sp.AppId}");
                         }
                     }
                 }
@@ -240,30 +170,28 @@ internal async Task<string> PrintTenantsList()
                 var tenantsJsonString = await AzureManagementAPI.ListTenantsAsync();
                 if (!string.IsNullOrEmpty(tenantsJsonString))
                 {
-                    using (JsonDocument document = JsonDocument.Parse(tenantsJsonString))
+                    using JsonDocument document = JsonDocument.Parse(tenantsJsonString);
+                    if (document.RootElement.TryGetProperty("value", out JsonElement jsonTenantElement))
                     {
-                        if (document.RootElement.TryGetProperty("value", out JsonElement jsonTenantElement))
+                        var jsonTenantEnumerator = jsonTenantElement.EnumerateArray();
+                        if (jsonTenantEnumerator.Any())
                         {
-                            var jsonTenantEnumerator = jsonTenantElement.EnumerateArray();
-                            if (jsonTenantEnumerator.Any())
+                            while (jsonTenantEnumerator.MoveNext())
                             {
-                                while (jsonTenantEnumerator.MoveNext())
-                                {
-                                    JsonElement current = jsonTenantEnumerator.Current;
-                                    string? tenantId = current.GetProperty("tenantId").GetString();
-                                    string? tenantType = current.GetProperty("tenantType").GetString();
-                                    string? defaultDomain = current.GetProperty("defaultDomain").GetString();
-                                    string? displayName = current.GetProperty("displayName").GetString();
-
-                                    tenantList.Add(
-                                        new TenantInformation()
-                                        {
-                                            TenantId = tenantId,
-                                            TenantType = tenantType,
-                                            DefaultDomain = defaultDomain,
-                                            DisplayName = displayName
-                                        });
-                                }
+                                JsonElement current = jsonTenantEnumerator.Current;
+                                string? tenantId = current.GetProperty("tenantId").GetString();
+                                string? tenantType = current.GetProperty("tenantType").GetString();
+                                string? defaultDomain = current.GetProperty("defaultDomain").GetString();
+                                string? displayName = current.GetProperty("displayName").GetString();
+
+                                tenantList.Add(
+                                    new TenantInformation()
+                                    {
+                                        TenantId = tenantId,
+                                        TenantType = tenantType,
+                                        DefaultDomain = defaultDomain,
+                                        DisplayName = displayName
+                                    });
                             }
                         }
                     }
@@ -275,15 +203,15 @@ internal async Task<string> PrintTenantsList()
                 JsonResponse jsonResponse = new JsonResponse(CommandName, State.Success, tenantList);
                 outputJsonString = jsonResponse.ToJsonString();
             }
-            else 
+            else
             {
                 Console.Write(
-                    "--------------------------------------------------------------------------------------------------------------------------------\n" + 
+                    "--------------------------------------------------------------------------------------------------------------------------------\n" +
                     "Display Name\t\t\tDefault Domain\t\t\t\tTenant Type\tTenant Id\n" +
                     "--------------------------------------------------------------------------------------------------------------------------------\n\n");
-                foreach(var tenant in tenantList)
+                foreach (var tenant in tenantList)
                 {
-                    Console.WriteLine($"{(tenant.DisplayName ?? string.Empty).PadRight(16)}\t\t{(tenant.DefaultDomain ?? string.Empty).PadRight(20)}\t\t{(tenant.TenantType ?? string.Empty).PadRight(10)}\t{(tenant.TenantId ?? string.Empty)}");
+                    Console.WriteLine($"{tenant.DisplayName ?? string.Empty,-16}\t\t{tenant.DefaultDomain ?? string.Empty,-20}\t\t{tenant.TenantType ?? string.Empty,-10}\t{tenant.TenantId ?? string.Empty}");
                 }
             }
             return outputJsonString;
diff --git a/src/Shared/Microsoft.DotNet.Scaffolding.Shared/CodeModifier/DocumentBuilder.cs b/src/Shared/Microsoft.DotNet.Scaffolding.Shared/CodeModifier/DocumentBuilder.cs
index 0ae47d815..be6711211 100644
--- a/src/Shared/Microsoft.DotNet.Scaffolding.Shared/CodeModifier/DocumentBuilder.cs
+++ b/src/Shared/Microsoft.DotNet.Scaffolding.Shared/CodeModifier/DocumentBuilder.cs
@@ -673,7 +673,7 @@ internal static SyntaxNode AddLambdaToParent(SyntaxNode parent, IEnumerable<Synt
             // Create lambda expression with parameter and block (add leading newline to block for formatting)
             var newLambdaExpression = SyntaxFactory.SimpleLambdaExpression(
                 parameter,
-                block.WithLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed, parentLeadingWhiteSpace));
+                block.WithLeadingTrivia(parentLeadingWhiteSpace));
 
             // Add lambda to parent block's argument list
             var argument = SyntaxFactory.Argument(newLambdaExpression);
diff --git a/src/Shared/Microsoft.DotNet.Scaffolding.Shared/ConsoleLogger.cs b/src/Shared/Microsoft.DotNet.Scaffolding.Shared/ConsoleLogger.cs
index 8ab64b15f..72469238f 100644
--- a/src/Shared/Microsoft.DotNet.Scaffolding.Shared/ConsoleLogger.cs
+++ b/src/Shared/Microsoft.DotNet.Scaffolding.Shared/ConsoleLogger.cs
@@ -6,10 +6,13 @@ namespace Microsoft.DotNet.MSIdentity.Shared
     internal class ConsoleLogger : IConsoleLogger
     {
         private readonly bool _jsonOutput;
-        private bool _silent;
+        private readonly bool _silent;
 
-        public ConsoleLogger(bool jsonOutput = false, bool silent = false)
+        private string CommandName { get; }
+
+        public ConsoleLogger(string commandName = null, bool jsonOutput = false, bool silent = false)
         {
+            CommandName = commandName ?? string.Empty;
             _jsonOutput = jsonOutput;
             _silent = silent;
             Console.OutputEncoding = Encoding.UTF8;
@@ -46,22 +49,25 @@ public void LogMessage(string message, LogMessageType level, bool removeNewLine
             }
         }
 
-        public void LogJsonMessage(JsonResponse jsonMessage)
+        public void LogJsonMessage(string state = null, object content = null, string output = null)
         {
             if (!_silent)
             {
                 if (_jsonOutput)
                 {
+                    var jsonMessage = new JsonResponse(CommandName, state, content, output);
                     Console.WriteLine(jsonMessage.ToJsonString());
                 }
                 else
                 {
-                    if (jsonMessage.State == State.Fail)
+                    if (state == State.Fail)
                     {
-                        LogMessage(jsonMessage.Output, LogMessageType.Error);
+                        LogMessage(output, LogMessageType.Error);
+                    }
+                    else
+                    {
+                        LogMessage(output);
                     }
-
-                    LogMessage(jsonMessage.Output);
                 }
             }
         }
@@ -73,5 +79,19 @@ public void LogMessage(string message, bool removeNewLine = false)
                 LogMessage(message, LogMessageType.Information, removeNewLine);
             }
         }
+
+        public void LogFailureAndExit(string failureMessage)
+        {
+            if (_jsonOutput)
+            {
+                LogJsonMessage(State.Fail, output: failureMessage);
+            }
+            else
+            {
+                LogMessage(failureMessage, LogMessageType.Error);
+            }
+
+            Environment.Exit(1);
+        }
     }
 }
diff --git a/src/Shared/Microsoft.DotNet.Scaffolding.Shared/IConsoleLogger.cs b/src/Shared/Microsoft.DotNet.Scaffolding.Shared/IConsoleLogger.cs
index 90cd50cc8..50b1f0178 100644
--- a/src/Shared/Microsoft.DotNet.Scaffolding.Shared/IConsoleLogger.cs
+++ b/src/Shared/Microsoft.DotNet.Scaffolding.Shared/IConsoleLogger.cs
@@ -4,7 +4,8 @@ public interface IConsoleLogger
     {
         void LogMessage(string message, LogMessageType level, bool removeNewLine = false);
         void LogMessage(string message, bool removeNewLine = false);
-        void LogJsonMessage(JsonResponse jsonMessage);
+        void LogJsonMessage(string state = null, object content = null, string output = null);
+        void LogFailureAndExit(string failureMessage);
     }
 
     public enum LogMessageType
diff --git a/src/Shared/Microsoft.DotNet.Scaffolding.Shared/JsonResponse.cs b/src/Shared/Microsoft.DotNet.Scaffolding.Shared/JsonResponse.cs
index 273fc7aed..e50e7faf4 100644
--- a/src/Shared/Microsoft.DotNet.Scaffolding.Shared/JsonResponse.cs
+++ b/src/Shared/Microsoft.DotNet.Scaffolding.Shared/JsonResponse.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Text.Json;
 
 namespace Microsoft.DotNet.MSIdentity.Shared
@@ -12,9 +11,9 @@ public class JsonResponse
 
         public JsonResponse(string command, string state = null, object content = null, string output = null)
         {
+            Command = command;
             State = state;
             Content = content;
-            Command = command ?? throw new ArgumentNullException(nameof(command));
             Output = output;
         }
 
diff --git a/test/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity.UnitTests.Tests/MsAADToolTests.cs b/test/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity.UnitTests.Tests/MsAADToolTests.cs
index 15c950950..c83405619 100644
--- a/test/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity.UnitTests.Tests/MsAADToolTests.cs
+++ b/test/MSIdentityScaffolding/Microsoft.DotNet.MSIdentity.UnitTests.Tests/MsAADToolTests.cs
@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Text.Json;
@@ -6,6 +7,7 @@
 using Microsoft.DotNet.MSIdentity.MicrosoftIdentityPlatformApplication;
 using Microsoft.DotNet.MSIdentity.Shared;
 using Microsoft.DotNet.MSIdentity.Tool;
+using Microsoft.Graph;
 using Moq;
 using Xunit;
 
@@ -58,5 +60,48 @@ public async void TestPrintTenantsList()
             Assert.True(aadB2CApp.TenantType.Equals("AAD B2C"));
             Assert.True(!string.IsNullOrEmpty(aadB2CApp.TenantId));
         }
+
+        [Fact]
+        public async void TestPrintApplicationsList_NoGraphObjects()
+        {
+            var directoryObjects = new List<DirectoryObject>();
+
+            Mock<IGraphObjectRetriever> graphObjectRetriever = new Mock<IGraphObjectRetriever>();
+            graphObjectRetriever.Setup(g => g.GetGraphObjects()).Returns(Task.FromResult(directoryObjects));
+
+            MsAADTool jsonAppTool = new MsAADTool(Commands.LIST_AAD_APPS_COMMAND, ToolOptions)
+            {
+                GraphObjectRetriever = graphObjectRetriever.Object
+            };
+
+            var expected = "{\"Command\":\"--list-aad-apps\",\"State\":\"Success\",\"Content\":[],\"Output\":null}";
+
+            var appsResponse = await jsonAppTool.PrintApplicationsList();
+            Assert.Equal(expected, appsResponse);
+        }
+
+        [Fact]
+        public async void TestGetApplications_OneAppB2C()
+        {
+            var app = new Application { AdditionalData = new Dictionary<string, object>() };
+            var directoryObjects = new List<DirectoryObject> { app };
+            var tenant = new Organization { TenantType = "AAD B2C" };
+            Mock<IGraphObjectRetriever> graphObjectRetriever = new Mock<IGraphObjectRetriever>();
+            graphObjectRetriever.Setup(g => g.GetGraphObjects()).Returns(Task.FromResult(directoryObjects));
+            graphObjectRetriever.Setup(g => g.GetTenant()).Returns(Task.FromResult(tenant));
+
+            MsAADTool jsonAppTool = new MsAADTool(Commands.LIST_AAD_APPS_COMMAND, ToolOptions)
+            {
+                GraphObjectRetriever = graphObjectRetriever.Object
+            };
+
+            var apps = await jsonAppTool.GetApplicationsAsync();
+            Assert.Equal(1, apps.Count);
+            var additionalData = apps.First()?.AdditionalData;
+            Assert.NotNull(additionalData);
+            Assert.True(additionalData.ContainsKey("IsB2C"));
+            additionalData.TryGetValue("IsB2C", out var isB2C);
+            Assert.True((bool)isB2C);
+        }
     }
 }