Add api to find unit processors based on search path (#5386)

Added EnvironmentVariables customization support for ProcessExecution.
Added ProcessorRunSettings to customize each processor run settings.
Currently only used to change path environment variables for processor
runs.
Added support to find unit processors based on search path. If search
paths not provided, the api will list all unit processors that can be
found.

Added e2e tests.

###### Microsoft Reviewers: [Open in
CodeFlow](https://microsoft.github.io/open-pr/?codeflow=https://github.com/microsoft/winget-cli/pull/5386)

---------

Co-authored-by: John McPherson <[email protected]>

Author: yao-msft

src/AppInstallerCLICore/Commands/DebugCommand.cpp

@@ -104,10 +104,13 @@ namespace AppInstaller::CLI
         OutputProxyStubInterfaceRegistration<winrt::Windows::Foundation::Collections::IIterable<winrt::Microsoft::Management::Configuration::IApplyGroupMemberSettingsResult>>(context);
         OutputProxyStubInterfaceRegistration<winrt::Windows::Foundation::Collections::IIterable<winrt::Microsoft::Management::Configuration::ITestSettingsResult>>(context);
         OutputProxyStubInterfaceRegistration<winrt::Windows::Foundation::Collections::IIterable<winrt::Microsoft::Management::Configuration::ConfigurationEnvironment>>(context);
+        OutputProxyStubInterfaceRegistration<winrt::Windows::Foundation::Collections::IIterable<winrt::Microsoft::Management::Configuration::IConfigurationUnitProcessorDetails>>(context);
         OutputProxyStubInterfaceRegistration<winrt::Microsoft::Management::Configuration::IConfigurationUnitProcessorDetails2>(context);
         OutputProxyStubInterfaceRegistration<winrt::Microsoft::Management::Configuration::IGetAllSettingsConfigurationUnitProcessor>(context);
         OutputProxyStubInterfaceRegistration<winrt::Microsoft::Management::Configuration::IGetAllUnitsConfigurationUnitProcessor>(context);
+        OutputProxyStubInterfaceRegistration<winrt::Microsoft::Management::Configuration::IFindUnitProcessorsSetProcessor>(context);
         OutputProxyStubInterfaceRegistration<winrt::Microsoft::Management::Configuration::IConfigurationStatics2>(context);
+        OutputProxyStubInterfaceRegistration<winrt::Microsoft::Management::Configuration::IConfigurationStatics3>(context);
         OutputProxyStubInterfaceRegistration<winrt::Microsoft::Management::Configuration::SetProcessorFactory::IPwshConfigurationSetProcessorFactoryProperties>(context);
 
         // TODO: Fix the layering inversion created by the COM deployment API (probably in order to operate winget.exe against the COM server).
@@ -135,6 +138,7 @@ namespace AppInstaller::CLI
     {
         OutputIIDMapping<winrt::Microsoft::Management::Configuration::IConfigurationStatics>(context);
         OutputIIDMapping<winrt::Microsoft::Management::Configuration::IConfigurationStatics2>(context);
+        OutputIIDMapping<winrt::Microsoft::Management::Configuration::IConfigurationStatics3>(context);
     }
 
     Resource::LocString DumpErrorResourceCommand::ShortDescription() const

src/AppInstallerCLICore/Commands/TestCommand.cpp

@@ -6,6 +6,7 @@
 
 #include "TestCommand.h"
 #include "AppInstallerRuntime.h"
+#include "TableOutput.h"
 #include "Public/ConfigurationSetProcessorFactoryRemoting.h"
 #include "Workflows/ConfigurationFlow.h"
 #include <winrt/Microsoft.Management.Configuration.h>
@@ -140,6 +141,80 @@ namespace AppInstaller::CLI
                     WriteConfigFile;
             }
         };
+
+        void InvokeFindUnitProcessors(Execution::Context& context)
+        {
+            auto& configurationContext = context.Get<Execution::Data::ConfigurationContext>();
+
+            winrt::Microsoft::Management::Configuration::FindUnitProcessorsOptions findOptions;
+
+            if (context.Args.Contains(Execution::Args::Type::InstallLocation))
+            {
+                findOptions.SearchPaths(Utility::ConvertToUTF16(context.Args.GetArg(Execution::Args::Type::InstallLocation)));
+                findOptions.SearchPathsExclusive(true);
+                findOptions.UnitDetailFlags(winrt::Microsoft::Management::Configuration::ConfigurationUnitDetailFlags::Local);
+            }
+
+            auto result = configurationContext.Processor().FindUnitProcessors(findOptions);
+
+            if (result.Size() > 0)
+            {
+                Execution::TableOutput<2> table(context.Reporter,
+                    {
+                        "Type"_lis,
+                        "Description"_lis
+                    });
+
+                for (const auto& resultUnitProcessor : result)
+                {
+                    table.OutputLine({
+                        Utility::ConvertToUTF8(resultUnitProcessor.UnitType()),
+                        Utility::ConvertToUTF8(resultUnitProcessor.UnitDescription())
+                        });
+                }
+
+                table.Complete();
+            }
+            else
+            {
+                context.Reporter.Info() << "No unit processors found."_lis << std::endl;
+            }
+        }
+
+        // Command to directly invoke find unit processors.
+        struct TestConfigurationFindUnitProcessorsCommand final : public Command
+        {
+            TestConfigurationFindUnitProcessorsCommand(std::string_view parent) : Command("config-find-unit-processors", {}, parent) {}
+
+            std::vector<Argument> GetArguments() const override
+            {
+                return {
+                    Argument{ Execution::Args::Type::InstallLocation, Resource::String::LocationArgumentDescription },
+                };
+            }
+
+            Resource::LocString ShortDescription() const override
+            {
+                return "Run find unit processors"_lis;
+            }
+
+            Resource::LocString LongDescription() const override
+            {
+                return "Runs find unit processors. Search paths could be provided."_lis;
+            }
+
+        protected:
+            void ExecuteInternal(Execution::Context& context) const override
+            {
+                context <<
+                    VerifyIsFullPackage <<
+                    CreateConfigurationProcessorWithoutFactory <<
+                    CreateOrOpenConfigurationSet{ "0.3" } <<
+                    EnsureDSCv3Processor <<
+                    CreateConfigurationProcessor <<
+                    InvokeFindUnitProcessors;
+            }
+        };
     }
 
     std::vector<std::unique_ptr<Command>> TestCommand::GetCommands() const
@@ -148,6 +223,7 @@ namespace AppInstaller::CLI
             {
                 std::make_unique<TestAppShutdownCommand>(FullName()),
                 std::make_unique<TestConfigurationExportCommand>(FullName()),
+                std::make_unique<TestConfigurationFindUnitProcessorsCommand>(FullName()),
             });
     }
 

src/AppInstallerCLICore/ConfigurationDynamicRuntimeFactory.cpp

@@ -155,7 +155,7 @@ namespace AppInstaller::CLI::ConfigurationRemoting
             IConfigurationSetProcessorFactory::Diagnostics_revoker DiagnosticsEventRevoker;
         };
 
-        struct DynamicSetProcessor : winrt::implements<DynamicSetProcessor, IConfigurationSetProcessor>
+        struct DynamicSetProcessor : winrt::implements<DynamicSetProcessor, IConfigurationSetProcessor, IFindUnitProcessorsSetProcessor>
         {
             using ProcessorMap = std::map<Security::IntegrityLevel, DynamicProcessorInfo>;
 
@@ -257,6 +257,21 @@ namespace AppInstaller::CLI::ConfigurationRemoting
                 return itr->second.Processor.CreateUnitProcessor(unit);
             }
 
+            Collections::IVector<IConfigurationUnitProcessorDetails> FindUnitProcessors(const FindUnitProcessorsOptions& findOptions)
+            {
+                IFindUnitProcessorsSetProcessor findUnitProcessorsSetProcessor;
+
+                if (m_setProcessors[m_currentIntegrityLevel].Processor.try_as<IFindUnitProcessorsSetProcessor>(findUnitProcessorsSetProcessor))
+                {
+                    return findUnitProcessorsSetProcessor.FindUnitProcessors(findOptions);
+                }
+                else
+                {
+                    AICLI_LOG(Config, Error, << "Set Processor does not support FindUnitProcessors operation");
+                    THROW_HR(WINGET_CONFIG_ERROR_NOT_SUPPORTED_BY_PROCESSOR);
+                }
+            }
+
         private:
             // Converts the string representation of SecurityContext to the target integrity level for this instance
             Security::IntegrityLevel SecurityContextToIntegrityLevel(SecurityContext securityContext)

src/AppInstallerCLICore/ExecutionReporter.cpp

@@ -175,7 +175,6 @@ namespace AppInstaller::CLI::Execution
             std::string response;
             if (!std::getline(m_in, response))
             {
-                m_in.get();
                 THROW_HR(APPINSTALLER_CLI_ERROR_PROMPT_INPUT_ERROR);
             }
 

src/AppInstallerCLIE2ETests/ConfigureCommand.cs

@@ -44,6 +44,7 @@ public void OneTimeSetup()
             WinGetSettingsHelper.ConfigureFeature("dsc3", true);
             this.DeleteResourceArtifacts();
             EnsureTestResourcePresence();
+            TestCommon.SetupTestSource(false);
         }
 
         /// <summary>
@@ -54,6 +55,7 @@ public void OneTimeTeardown()
         {
             WinGetSettingsHelper.ConfigureFeature("dsc3", false);
             this.DeleteResourceArtifacts();
+            TestCommon.TearDownTestSource();
         }
 
         /// <summary>
@@ -366,6 +368,39 @@ public void ConfigureFromTestRepo_DSCv3()
             Assert.AreEqual("Contents!", File.ReadAllText(targetFilePath));
         }
 
+        /// <summary>
+        /// Find unit processors tests.
+        /// </summary>
+        [Test]
+        public void ConfigureFindUnitProcessors()
+        {
+            // Find all unit processors.
+            var result = TestCommon.RunAICLICommand("test config-find-unit-processors", string.Empty);
+            Assert.AreEqual(0, result.ExitCode);
+            Assert.True(result.StdOut.Contains("Microsoft/OSInfo"));
+
+            // Setup TestExeInstaller with dsc resources.
+            var installDir = TestCommon.GetRandomTestDir();
+            result = TestCommon.RunAICLICommand("install", $"AppInstallerTest.TestExeInstaller --override \"/InstallDir {installDir} /GenerateDscResourceFiles\"");
+            Assert.AreEqual(0, result.ExitCode);
+
+            // Find unit processors filtering to install location.
+            result = TestCommon.RunAICLICommand("test config-find-unit-processors", $"-l {installDir}");
+            Assert.AreEqual(0, result.ExitCode);
+            Assert.False(result.StdOut.Contains("Microsoft/OSInfo"));
+            Assert.True(result.StdOut.Contains("AppInstallerTest/TestResource"));
+
+            // Find unit processors filtering to unknown location.
+            var unknownDir = TestCommon.GetRandomTestDir();
+            result = TestCommon.RunAICLICommand("test config-find-unit-processors", $"-l {unknownDir}");
+            Assert.AreEqual(0, result.ExitCode);
+            Assert.True(result.StdOut.Contains("No unit processors found."));
+
+            // Clean up
+            result = TestCommon.RunAICLICommand("uninstall", "AppInstallerTest.TestExeInstaller");
+            Assert.AreEqual(0, result.ExitCode);
+        }
+
         private void DeleteResourceArtifacts()
         {
             // Delete all .txt files in the test directory; they are placed there by the tests

src/AppInstallerCLIPackage/Package.appxmanifest

@@ -114,10 +114,13 @@
         <Interface Name="Windows.Foundation.Collections.IIterable`1&lt;Microsoft.Management.Configuration.IApplyGroupMemberSettingsResult&gt;" InterfaceId="5086070C-F468-5B00-8352-50FB420BA8B0" />
         <Interface Name="Windows.Foundation.Collections.IIterable`1&lt;Microsoft.Management.Configuration.ITestSettingsResult&gt;" InterfaceId="2D28E6AA-7036-5D78-9B58-9456F1E332FE" />
         <Interface Name="Windows.Foundation.Collections.IIterable`1&lt;Microsoft.Management.Configuration.ConfigurationEnvironment&gt;" InterfaceId="47B18106-976B-5532-8E81-F58D304DFA43" />
+        <Interface Name="Windows.Foundation.Collections.IIterable`1&lt;Microsoft.Management.Configuration.IConfigurationUnitProcessorDetails&gt;" InterfaceId="055865E9-B633-5AD6-9C8F-55DFCD668E74" />
         <Interface Name="Microsoft.Management.Configuration.IConfigurationUnitProcessorDetails2" InterfaceId="E89623ED-76E2-5145-B920-D09659554E35" />
         <Interface Name="Microsoft.Management.Configuration.IGetAllSettingsConfigurationUnitProcessor" InterfaceId="72EB8304-D8D3-57D4-9940-7C1C4AD8C40C" />
         <Interface Name="Microsoft.Management.Configuration.IGetAllUnitsConfigurationUnitProcessor" InterfaceId="D5CB3357-8AD6-5A3C-8695-057C01867D5F" />
+        <Interface Name="Microsoft.Management.Configuration.IFindUnitProcessorsSetProcessor" InterfaceId="620628DF-A5DE-591A-B738-FD8370B4E95C" />
         <Interface Name="Microsoft.Management.Configuration.IConfigurationStatics2" InterfaceId="540BE073-F2EF-5375-83AA-8E23086B0669" />
+        <Interface Name="Microsoft.Management.Configuration.IConfigurationStatics3" InterfaceId="C84E137B-90E5-5F63-931D-F0497BBCA847" />
         <Interface Name="Microsoft.Management.Configuration.SetProcessorFactory.IPwshConfigurationSetProcessorFactoryProperties" InterfaceId="2C298A30-BD3B-5D00-BCD1-2EB633AB7E3B" />
       </ProxyStub>
     </Extension>