Improve configure user experience

src/AppInstallerCLICore/ChannelStreams.cpp

@@ -6,7 +6,6 @@
 
 namespace AppInstaller::CLI::Execution
 {
-    using namespace Settings;
     using namespace VirtualTerminal;
 
     size_t GetConsoleWidth()

src/AppInstallerCLICore/Command.cpp

@@ -4,6 +4,8 @@
 #include "Command.h"
 #include "Resources.h"
 #include <winget/UserSettings.h>
+#include <AppInstallerRuntime.h>
+#include <winget/Locale.h>
 
 using namespace std::string_view_literals;
 using namespace AppInstaller::Utility::literals;

src/AppInstallerCLICore/Commands/ConfigureCommand.cpp

@@ -54,6 +54,7 @@ namespace AppInstaller::CLI
     void ConfigureCommand::ExecuteInternal(Execution::Context& context) const
     {
         context <<
+            VerifyFile(Execution::Args::Type::ConfigurationFile) <<
             CreateConfigurationProcessor <<
             OpenConfigurationSet <<
             ShowConfigurationSet <<

src/AppInstallerCLICore/Commands/ConfigureShowCommand.cpp

@@ -35,6 +35,7 @@ namespace AppInstaller::CLI
     void ConfigureShowCommand::ExecuteInternal(Execution::Context& context) const
     {
         context <<
+            VerifyFile(Execution::Args::Type::ConfigurationFile) <<
             CreateConfigurationProcessor <<
             OpenConfigurationSet <<
             ShowConfigurationSet;

src/AppInstallerCLICore/Commands/RootCommand.cpp

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 #include "pch.h"
 #include "RootCommand.h"
+#include <AppInstallerRuntime.h>
 
 #include "InstallCommand.h"
 #include "ShowCommand.h"

src/AppInstallerCLICore/Commands/ValidateCommand.cpp

@@ -5,6 +5,7 @@
 #include "Workflows/WorkflowBase.h"
 #include "Workflows/DependenciesFlow.h"
 #include "Resources.h"
+#include <winget/ManifestYamlParser.h>
 
 namespace AppInstaller::CLI
 {

src/AppInstallerCLICore/CompletionData.cpp

@@ -3,12 +3,13 @@
 #include "pch.h"
 #include "CompletionData.h"
 #include "Resources.h"
+#include <AppInstallerLogging.h>
+#include <AppInstallerErrors.h>
 
 namespace AppInstaller::CLI
 {
     using namespace std::string_view_literals;
     using namespace Utility::literals;
-    using namespace Settings;
 
     // Completion takes in the following values:
     //  Word :: The token from the command line that is being targeted for completion.

src/AppInstallerCLICore/ConfigurationSetProcessorFactoryRemoting.cpp

@@ -2,6 +2,8 @@
 // Licensed under the MIT License.
 #include "pch.h"
 #include "ConfigurationSetProcessorFactoryRemoting.h"
+#include <AppInstallerLogging.h>
+#include <AppInstallerRuntime.h>
 
 using namespace winrt::Windows::Foundation;
 using namespace winrt::Microsoft::Management::Configuration;

src/AppInstallerCLICore/ExecutionProgress.cpp

@@ -166,7 +166,12 @@ namespace AppInstaller::CLI::Execution
 
         void ProgressVisualizerBase::SetMessage(std::string_view message)
         {
-            m_message = message;
+            std::atomic_store(&m_message, std::make_shared<std::string>(message));
+        }
+
+        std::shared_ptr<std::string> ProgressVisualizerBase::GetMessage()
+        {
+            return std::atomic_load(&m_message);
         }
     }
 
@@ -213,7 +218,8 @@ namespace AppInstaller::CLI::Execution
                 ApplyStyle(i % repetitionCount, repetitionCount, true);
                 m_out << '\r' << indent << spinnerChars[i % ARRAYSIZE(spinnerChars)];
                 m_out.RestoreDefault();
-                m_out << ' ' << m_message << std::flush;
+                std::shared_ptr<std::string> message = this->GetMessage();
+                m_out << ' ' << (message ? *message : std::string{}) << std::flush;
                 Sleep(250);
             }
 

src/AppInstallerCLICore/ExecutionProgress.h

@@ -11,6 +11,7 @@
 #include <atomic>
 #include <future>
 #include <istream>
+#include <memory>
 #include <ostream>
 #include <string>
 #include <vector>
@@ -28,11 +29,11 @@ namespace AppInstaller::CLI::Execution
             void SetStyle(AppInstaller::Settings::VisualStyle style) { m_style = style; }
 
             void SetMessage(std::string_view message);
+            std::shared_ptr<std::string> GetMessage();
 
         protected:
             BaseStream& m_out;
             Settings::VisualStyle m_style = AppInstaller::Settings::VisualStyle::Accent;
-            std::string m_message;
 
             bool UseVT() const { return m_enableVT && m_style != AppInstaller::Settings::VisualStyle::NoVT; }
 
@@ -43,6 +44,7 @@ namespace AppInstaller::CLI::Execution
 
         private:
             bool m_enableVT = false;
+            std::shared_ptr<std::string> m_message;
         };
     }
 

src/AppInstallerCLICore/ExecutionReporter.cpp

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 #include "pch.h"
 #include "ExecutionReporter.h"
+#include <AppInstallerErrors.h>
 
 
 namespace AppInstaller::CLI::Execution
@@ -246,9 +247,50 @@ namespace AppInstaller::CLI::Execution
         GetBasicOutputStream() << VirtualTerminal::Cursor::Visibility::EnableShow;
     };
 
+    Reporter::AsyncProgressScope::AsyncProgressScope(Reporter& reporter, IProgressSink* sink, bool hideProgressWhenDone) :
+        m_reporter(reporter), m_callback(sink)
+    {
+        reporter.SetProgressCallback(&m_callback);
+        sink->BeginProgress();
+        m_hideProgressWhenDone = hideProgressWhenDone;
+    }
+
+    Reporter::AsyncProgressScope::~AsyncProgressScope()
+    {
+        m_reporter.get().SetProgressCallback(nullptr);
+        m_callback.GetSink()->EndProgress(m_hideProgressWhenDone);
+    }
+
+    ProgressCallback& Reporter::AsyncProgressScope::Callback()
+    {
+        return m_callback;
+    }
+
+    IProgressCallback* Reporter::AsyncProgressScope::operator->()
+    {
+        return &m_callback;
+    }
+
+    bool Reporter::AsyncProgressScope::HideProgressWhenDone() const
+    {
+        return m_hideProgressWhenDone;
+    }
+
+    void Reporter::AsyncProgressScope::HideProgressWhenDone(bool value)
+    {
+        m_hideProgressWhenDone.store(value);
+    }
+
+    std::unique_ptr<Reporter::AsyncProgressScope> Reporter::BeginAsyncProgress(bool hideProgressWhenDone)
+    {
+        return std::make_unique<AsyncProgressScope>(*this, m_progressSink.load(), hideProgressWhenDone);
+    }
+
     void Reporter::SetProgressCallback(ProgressCallback* callback)
     {
         auto lock = m_progressCallbackLock.lock_exclusive();
+        // Attempting two progress operations at the same time; not supported.
+        THROW_HR_IF(HRESULT_FROM_WIN32(ERROR_INVALID_STATE), m_progressCallback != nullptr && callback != nullptr);
         m_progressCallback = callback;
     }
 

src/AppInstallerCLICore/ExecutionReporter.h

@@ -13,6 +13,7 @@
 #include <atomic>
 #include <iomanip>
 #include <istream>
+#include <memory>
 #include <optional>
 #include <ostream>
 #include <string>
@@ -116,23 +117,41 @@ namespace AppInstaller::CLI::Execution
         void SetProgressMessage(std::string_view message) override;
         void EndProgress(bool hideProgressWhenDone) override;
 
+        // Contains the objects used for async progress and the lifetime of said progress.
+        struct AsyncProgressScope
+        {
+            AsyncProgressScope(Reporter& reporter, IProgressSink* sink, bool hideProgressWhenDone);
+            ~AsyncProgressScope();
+
+            AsyncProgressScope(const AsyncProgressScope&) = delete;
+            AsyncProgressScope& operator=(const AsyncProgressScope&) = delete;
+
+            AsyncProgressScope(AsyncProgressScope&&) = delete;
+            AsyncProgressScope& operator=(AsyncProgressScope&&) = delete;
+
+            ProgressCallback& Callback();
+            IProgressCallback* operator->();
+
+            bool HideProgressWhenDone() const;
+            void HideProgressWhenDone(bool value);
+
+        private:
+            std::reference_wrapper<Reporter> m_reporter;
+            ProgressCallback m_callback;
+            std::atomic_bool m_hideProgressWhenDone;
+        };
+
         // Runs the given callable of type: auto(IProgressCallback&)
         template <typename F>
         auto ExecuteWithProgress(F&& f, bool hideProgressWhenDone = false)
         {
-            IProgressSink* sink = m_progressSink.load();
-            ProgressCallback callback(sink);
-            SetProgressCallback(&callback);
-            sink->BeginProgress();
-
-            auto hideProgress = wil::scope_exit([this, hideProgressWhenDone]()
-                {
-                    SetProgressCallback(nullptr);
-                    m_progressSink.load()->EndProgress(hideProgressWhenDone);
-                });
-            return f(callback);
+            auto progressScope = BeginAsyncProgress(hideProgressWhenDone);
+            return f(progressScope->Callback());
         }
 
+        // Begins an asynchronous progress operation.
+        std::unique_ptr<AsyncProgressScope> BeginAsyncProgress(bool hideProgressWhenDone = false);
+
         // Sets the in progress callback.
         void SetProgressCallback(ProgressCallback* callback);
 

src/AppInstallerCLICore/PackageCollection.cpp

@@ -1,11 +1,11 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 #include "pch.h"
-
 #include "PackageCollection.h"
 
-#include "AppInstallerRuntime.h"
-#include "winget/JsonSchemaValidation.h"
+#include <AppInstallerLogging.h>
+#include <AppInstallerRuntime.h>
+#include <winget/JsonSchemaValidation.h>
 
 #include "PackagesSchema.h"
 

src/AppInstallerCLICore/PortableInstaller.cpp

@@ -10,6 +10,7 @@
 #include "Microsoft/PortableIndex.h"
 #include "Microsoft/Schema/IPortableIndex.h"
 #include <AppInstallerErrors.h>
+#include <AppInstallerRuntime.h>
 
 using namespace AppInstaller::Utility;
 using namespace AppInstaller::Registry;

src/AppInstallerCLICore/Resources.h

@@ -51,20 +51,44 @@ namespace AppInstaller::CLI::Resource
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationApply);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationAssert);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationDependencies);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationDescriptionWasTruncated);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationFailedToApply);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationFailedToGetDetails);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationFieldInvalid);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationFileArgumentDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationFileEmpty);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationFileInvalid);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationFileVersionUnknown);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationGettingDetails);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationInform);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationInitializing);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationLocal);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationModuleNameOnly);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationModuleWithDetails);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationReadingConfigFile);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationSettings);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationSuccessfullyApplied);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitAssertHadNegativeResult);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitFailed);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitFailedConfigSet);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitFailedDuringGet);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitFailedDuringSet);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitFailedDuringTest);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitFailedInternal);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitFailedPrecondition);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitFailedSystemState);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitFailedUnitProcessing);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitHasDuplicateIdentifier);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitHasMissingDependency);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitManuallySkipped);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitModuleConflict);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitModuleImportFailed);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitMultipleMatches);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitNotFound);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitNotFoundInModule);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitNotRunDueToDependency);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitNotRunDueToFailedAssert);
+        WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitReturnedInvalidResult);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationUnitSkipped);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationWaitingOnAnother);
         WINGET_DEFINE_RESOURCE_STRINGID(ConfigurationWarning);

src/AppInstallerCLICore/VTSupport.cpp

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 #include "pch.h"
 #include "VTSupport.h"
+#include <AppInstallerLogging.h>
 
 
 namespace AppInstaller::CLI::VirtualTerminal