CP -> releases/2.0.2 Fix silent auth failure in WSL caused by broker token provider (#675) (#676)

WSL reports as Linux but has no msalruntime daemon, causing
MsalSilentTokenProvider to fail when using appInteractiveBroker.

- Add PlatformInformation.IsWSL() to detect WSL via
RuntimeInformation.IsOSPlatform(Linux) and WSL_DISTRO_NAME env var
- Use non-broker app for silent auth on WSL, matching behavior before
0cddac6
- Add tests for WSL and non-WSL silent auth provider selection

### Problem
Commit #664 (#666) changed `MsalSilentTokenProvidert`o use
`appInteractiveBroker ?? app` so that the broker's token cache is
queried on silent auth. This works correctly on Windows and macOS, but
breaks Windows Subsystem for Linux (WSL) due to stdout corruption from
MSAL linux broker subprocesses.
Related MSAL issue:
AzureAD/microsoft-authentication-library-for-dotnet#5979

### work around until MSAL responds
Add `PlatformInformation.IsWSL()` which returns true when the runtime OS
is Linux and the WSL_DISTRO_NAME environment variable is set (always
present in WSL sessions, never set on native Linux/macOS/Windows). In
`MsalTokenProviders.Get()` use the non-broker app for silent auth when
running in WSL, restoring the pre-#664 behavior for WSL users while
keeping broker-accelerated silent auth on Windows and macOS.

### Testing
Added unit tests covering silent provider selection under WSL and
non-WSL conditions with both empty and warm MSAL caches.

Author: embetten

src/Authentication.Tests/TokenProviderTests.cs

@@ -177,8 +177,14 @@ public void MsalManagedIdentityContractTest()
     }
 
     [TestMethod]
-    public async Task MsalTokenProviders_SilentProvider_UsesBrokerApp_WhenProvided()
+    public async Task MsalTokenProviders_SilentProvider_UsesBrokerApp_WhenProvided_NonWSL()
     {
+        if (PlatformInformation.IsWSL())
+        {
+            // On WSL the broker app is intentionally skipped for silent auth; see the WSL test below.
+            Assert.Inconclusive("Skipped on WSL — broker silent auth is disabled there by design.");
+        }
+
         // Arrange: create two distinct app mocks (Loose so other providers in the iterator don't fail)
         var nonBrokerApp = new Mock<IPublicClientApplication>();
         var brokerApp = new Mock<IPublicClientApplication>();
@@ -207,6 +213,43 @@ public async Task MsalTokenProviders_SilentProvider_UsesBrokerApp_WhenProvided()
         nonBrokerApp.Verify(x => x.GetAccountsAsync(), Times.Never);
     }
 
+    [TestMethod]
+    public async Task MsalTokenProviders_SilentProvider_UsesNonBrokerApp_OnWSL()
+    {
+        if (!PlatformInformation.IsWSL())
+        {
+            Assert.Inconclusive("Skipped on non-WSL — this test validates WSL-specific broker bypass behavior.");
+        }
+
+        // Arrange: on WSL the silent provider should use the non-broker app even when a broker app is provided,
+        // because the Linux broker daemon does not exist in WSL.
+        // See: https://github.com/microsoft/artifacts-credprovider/issues/TODO
+        var nonBrokerApp = new Mock<IPublicClientApplication>();
+        var brokerApp = new Mock<IPublicClientApplication>();
+
+        nonBrokerApp.Setup(x => x.GetAccountsAsync())
+            .ReturnsAsync(Array.Empty<IAccount>());
+        nonBrokerApp.Setup(x => x.Authority)
+            .Returns("https://login.microsoftonline.com/common");
+        var nonBrokerAppConfig = new Mock<IAppConfig>();
+        nonBrokerAppConfig.Setup(x => x.IsBrokerEnabled).Returns(false);
+        nonBrokerApp.Setup(x => x.AppConfig).Returns(nonBrokerAppConfig.Object);
+
+        // broker app should NOT be called on WSL
+        brokerApp.Setup(x => x.GetAccountsAsync())
+            .ReturnsAsync(Array.Empty<IAccount>());
+
+        var providers = MsalTokenProviders.Get(nonBrokerApp.Object, loggerMock.Object, appInteractiveBroker: brokerApp.Object).ToList();
+        var silentProvider = providers.First(p => p.Name == "MSAL Silent");
+
+        // Act
+        await silentProvider.GetTokenAsync(new TokenRequest());
+
+        // Assert: non-broker app was used on WSL, broker app was not called
+        nonBrokerApp.Verify(x => x.GetAccountsAsync(), Times.Once);
+        brokerApp.Verify(x => x.GetAccountsAsync(), Times.Never);
+    }
+
     [TestMethod]
     public async Task MsalTokenProviders_SilentProvider_UsesNonBrokerApp_WhenNoBrokerProvided()
     {

src/Authentication/MsalTokenProviders.cs

@@ -15,8 +15,11 @@ public static IEnumerable<ITokenProvider> Get(IPublicClientApplication app, ILog
         yield return new MsalManagedIdentityTokenProvider(app, logger);
 
         // TODO: Would be more useful if MsalSilentTokenProvider enumerated over each account from the outside
-        // Use the broker app for silent auth when available so WAM cache can be queried
-        yield return new MsalSilentTokenProvider(appInteractiveBroker ?? app, logger);
+
+        // Use the broker app for silent auth on Windows and macOS so the broker cache can be queried.
+        // WSL reports as Linux but has no broker daemon, so fall back to the non-broker app there.
+        // See: https://github.com/AzureAD/microsoft-authentication-library-for-dotnet/issues/5979
+        yield return new MsalSilentTokenProvider(PlatformInformation.IsWSL() ? app : appInteractiveBroker ?? app, logger);
 
         if (WindowsIntegratedAuth.IsSupported())
         {

src/Authentication/PlatformInformation.cs

@@ -79,4 +79,14 @@ public static string GetClrDescription()
     {
         return RuntimeInformation.FrameworkDescription;
     }
+
+    /// <summary>
+    /// Returns true when running inside Windows Subsystem for Linux (WSL).
+    /// WSL always sets the WSL_DISTRO_NAME environment variable.
+    /// </summary>
+    public static bool IsWSL()
+    {
+        return RuntimeInformation.IsOSPlatform(OSPlatform.Linux)
+            && !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("WSL_DISTRO_NAME"));
+    }
 }