Use environment variable for CachePlugins feature flag

- Changed from static dictionary to environment variable check (MSBUILD_CACHEPLUGINS_DISABLED)
- VS can now control the feature via remote flag by setting the environment variable
- Updated tests to use environment variable instead of SetFeatureAvailability
- Follows the same pattern as other MSBuild features like MSBUILD_TELEMETRY_OPTOUT
- All 100 project cache tests pass

Co-authored-by: YuliiaKovalova <[email protected]>

Author: Copilot

src/Build.UnitTests/ProjectCache/ProjectCacheTests.cs

@@ -1753,14 +1753,13 @@ static void Main()
         [Fact]
         public void CachePluginsFeatureFlagDisablesCache()
         {
-            // This test verifies that when the CachePlugins feature is disabled,
+            // This test verifies that when the CachePlugins feature is disabled via environment variable,
             // the cache plugin is not used even when configured.
 
+            _env.SetEnvironmentVariable("MSBUILD_CACHEPLUGINS_DISABLED", "1");
+
             try
             {
-                // Disable the cache plugins feature
-                Framework.Features.SetFeatureAvailability("CachePlugins", Framework.FeatureStatus.NotAvailable);
-
                 var testData = new GraphCacheResponse(
                     new Dictionary<int, int[]?>
                     {
@@ -1802,8 +1801,7 @@ public void CachePluginsFeatureFlagDisablesCache()
             }
             finally
             {
-                // Restore the feature to its default state
-                Framework.Features.ResetFeatureStatusForTests();
+                _env.SetEnvironmentVariable("MSBUILD_CACHEPLUGINS_DISABLED", null);
             }
         }
 
@@ -1813,55 +1811,47 @@ public void CachePluginsFeatureFlagEnabled()
             // This test verifies that when the CachePlugins feature is enabled (default),
             // the cache plugin is used as expected.
 
-            try
-            {
-                // Explicitly enable the cache plugins feature (though it should be enabled by default)
-                Framework.Features.SetFeatureAvailability("CachePlugins", Framework.FeatureStatus.Available);
-
-                var testData = new GraphCacheResponse(
-                    new Dictionary<int, int[]?>
-                    {
-                        {1, null}
-                    },
-                    new Dictionary<int, CacheResult>
-                    {
-                        {1, GraphCacheResponse.SuccessfulProxyTargetResult()}
-                    });
-
-                var graph = testData.CreateGraph(_env);
+            // Ensure the environment variable is not set (feature enabled by default)
+            _env.SetEnvironmentVariable("MSBUILD_CACHEPLUGINS_DISABLED", null);
 
-                var mockCache = new InstanceMockCache(testData);
-
-                var buildParameters = new BuildParameters
+            var testData = new GraphCacheResponse(
+                new Dictionary<int, int[]?>
                 {
-                    ProjectCacheDescriptor = ProjectCacheDescriptor.FromInstance(mockCache)
-                };
-
-                MockLogger logger;
-                GraphBuildResult graphResult;
-                using (var buildSession = new Helpers.BuildManagerSession(_env, buildParameters))
+                    {1, null}
+                },
+                new Dictionary<int, CacheResult>
                 {
-                    logger = buildSession.Logger;
-                    graphResult = buildSession.BuildGraph(graph);
-                }
+                    {1, GraphCacheResponse.SuccessfulProxyTargetResult()}
+                });
 
-                graphResult.OverallResult.ShouldBe(BuildResultCode.Success);
+            var graph = testData.CreateGraph(_env);
 
-                // Verify that cache WAS used (plugin methods were called)
-                mockCache.BeginBuildCalled.ShouldBeTrue("BeginBuildAsync should be called when feature is enabled");
-                mockCache.Requests.ShouldNotBeEmpty("GetCacheResultAsync should be called when feature is enabled");
-                mockCache.EndBuildCalled.ShouldBeTrue("EndBuildAsync should be called when feature is enabled");
+            var mockCache = new InstanceMockCache(testData);
 
-                // The build should have succeeded using the cache
-                logger.FullLog.ShouldContain("MockCache: BeginBuildAsync");
-                logger.FullLog.ShouldContain("MockCache: GetCacheResultAsync");
-                logger.FullLog.ShouldContain("MockCache: EndBuildAsync");
-            }
-            finally
+            var buildParameters = new BuildParameters
             {
-                // Restore the feature to its default state
-                Framework.Features.ResetFeatureStatusForTests();
+                ProjectCacheDescriptor = ProjectCacheDescriptor.FromInstance(mockCache)
+            };
+
+            MockLogger logger;
+            GraphBuildResult graphResult;
+            using (var buildSession = new Helpers.BuildManagerSession(_env, buildParameters))
+            {
+                logger = buildSession.Logger;
+                graphResult = buildSession.BuildGraph(graph);
             }
+
+            graphResult.OverallResult.ShouldBe(BuildResultCode.Success);
+
+            // Verify that cache WAS used (plugin methods were called)
+            mockCache.BeginBuildCalled.ShouldBeTrue("BeginBuildAsync should be called when feature is enabled");
+            mockCache.Requests.ShouldNotBeEmpty("GetCacheResultAsync should be called when feature is enabled");
+            mockCache.EndBuildCalled.ShouldBeTrue("EndBuildAsync should be called when feature is enabled");
+
+            // The build should have succeeded using the cache
+            logger.FullLog.ShouldContain("MockCache: BeginBuildAsync");
+            logger.FullLog.ShouldContain("MockCache: GetCacheResultAsync");
+            logger.FullLog.ShouldContain("MockCache: EndBuildAsync");
         }
     }
 }

src/Framework/Features.cs

@@ -43,7 +43,6 @@ private static Dictionary<string, FeatureStatus> CreateDefaultFeatureStatusMap()
             return new Dictionary<string, FeatureStatus>
             {
                 { "BuildCheck.Beta", FeatureStatus.Preview },
-                { "CachePlugins", FeatureStatus.Available }, // Project cache plugins (e.g., Quickbuild) are enabled by default but can be remotely disabled.
                 { "EvaluationContext_SharedSDKCachePolicy", FeatureStatus.Available }, // EvaluationContext supports the SharingPolicy.SharedSDKCache flag.
                 { "TerminalLogger_MultiLineHandler", FeatureStatus.Available }, // TerminalLogger has better explicit support for rendering multi-line messages
                 // Add more features here.
@@ -57,6 +56,20 @@ private static Dictionary<string, FeatureStatus> CreateDefaultFeatureStatusMap()
         /// <returns>A feature status <see cref="FeatureStatus"/>.</returns>
         public static FeatureStatus CheckFeatureAvailability(string featureName)
         {
+            // Special handling for CachePlugins feature - controlled via environment variable
+            // This allows remote feature flags in VS to disable cache plugins by setting the environment variable
+            if (featureName == "CachePlugins")
+            {
+                string? envValue = System.Environment.GetEnvironmentVariable("MSBUILD_CACHEPLUGINS_DISABLED");
+                if (!string.IsNullOrEmpty(envValue) && 
+                    (envValue.Equals("1", System.StringComparison.OrdinalIgnoreCase) || 
+                     envValue.Equals("true", System.StringComparison.OrdinalIgnoreCase)))
+                {
+                    return FeatureStatus.NotAvailable;
+                }
+                return FeatureStatus.Available;
+            }
+
             return _featureStatusMap.TryGetValue(featureName, out FeatureStatus status) ?
                  status : FeatureStatus.Undefined;
         }