Prefer identity channel for DotNet template resolution

The cherry-picks of #17564 and #17573 alone do not address the
`aspire new` + C# Blazor scenario from #17596 because that path
runs through `TemplateNuGetConfigService.ResolveTemplatePackageAsync`
(DotNet templates), not `NewCommand.ResolveCliTemplateVersionAsync`
(CLI-runtime templates) where #17564's `TryGetCurrentCliTemplateVersionPackage`
synthesis lives.

Teach `ResolveTemplatePackageAsync` to mirror the identity-channel
preference that `ResolveCliTemplateVersionAsync` (NewCommand.cs:376-389)
already does for CLI templates: when no `--channel` is supplied and no
PR hives exist, prefer the channel whose name matches the running CLI's
`CliExecutionContext.IdentityChannel` before falling back to Implicit.

Without this, a daily 13.5 CLI on a clean `~/.aspire` silently restricts
the template search to nuget.org and returns the shipped stable
`Aspire.ProjectTemplates 13.3.5` instead of the matching
`13.5.0-preview.1.*` daily prerelease from the `dotnet9` feed.

The Implicit fallback preserves prior behavior when the identity channel
isn't a registered channel (e.g. a "local" CLI without a corresponding
local-build hive).

See #17596 for full repro.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: mitchdenny

src/Aspire.Cli/Templating/TemplateNuGetConfigService.cs

@@ -224,13 +224,44 @@ public async Task<TemplatePackageSelection> ResolveTemplatePackageAsync(Template
                     $"{string.Join(", ", allChannels.Select(c => c.Name))}");
             channels = [matchingChannel];
         }
+        else if (hasPrHives)
+        {
+            // If there are hives (PR build directories), include all channels so a
+            // PR-installed CLI can find its matching local-hive templates.
+            channels = allChannels;
+        }
         else
         {
-            // If there are hives (PR build directories), include all channels.
-            // Otherwise, only use the implicit/default channel to avoid prompting.
-            channels = hasPrHives
-                ? allChannels
-                : allChannels.Where(c => c.Type is PackageChannelType.Implicit);
+            // Prefer the channel whose name matches the running CLI's identity
+            // (CliExecutionContext.IdentityChannel — stable, staging, daily, local,
+            // or pr-<N>). This keeps DotNet templates (C# Blazor / aspire-starter)
+            // lock-stepped with the CLI a developer just installed: a daily 13.5
+            // CLI resolves Aspire.ProjectTemplates from the daily feed, not from
+            // whatever stable version happens to be live on nuget.org.
+            //
+            // Without this, `TemplateNuGetConfigService` only queried the Implicit
+            // (nuget.org) channel when neither --channel was passed nor PR hives
+            // existed, so a clean ~/.aspire on a daily CLI silently resolved the
+            // shipped stable Aspire.ProjectTemplates (e.g. 13.3.5) while the daily
+            // 13.5.0-preview.1.* package on the dotnet9 feed was never seen. See
+            // https://github.com/microsoft/aspire/issues/17596 for the full repro.
+            //
+            // ResolveCliTemplateVersionAsync (NewCommand.cs) already does the same
+            // identity-channel preference for CLI-runtime templates; this brings
+            // DotNet templates in line. The Implicit fallback preserves the prior
+            // behavior when the identity channel isn't a registered channel (e.g.
+            // a "local" CLI without a corresponding local-build hive).
+            PackageChannel? identityChannelMatch = null;
+            if (!string.IsNullOrWhiteSpace(executionContext.IdentityChannel))
+            {
+                identityChannelMatch = allChannels.FirstOrDefault(c =>
+                    string.Equals(c.Name, executionContext.IdentityChannel, StringComparison.OrdinalIgnoreCase));
+            }
+
+            var implicitChannel = allChannels.FirstOrDefault(c => c.Type is PackageChannelType.Implicit);
+            channels = identityChannelMatch is not null
+                ? [identityChannelMatch]
+                : implicitChannel is not null ? [implicitChannel] : [];
         }
 
         var packagesFromChannels = await interactionService.ShowStatusAsync(Resources.TemplatingStrings.SearchingForAvailableTemplateVersions, async () =>

tests/Aspire.Cli.Tests/Templating/TemplateNuGetConfigServiceTests.cs

@@ -212,11 +212,15 @@ public async Task CreateOrUpdateNuGetConfigWithoutPromptAsync_NullChannelName_Sh
     }
 
     [Fact]
-    public async Task ResolveTemplatePackageAsync_NullRequestedChannel_UsesImplicitChannelOnly()
+    public async Task ResolveTemplatePackageAsync_NullRequestedChannel_NoIdentityChannelMatch_UsesImplicitChannelOnly()
     {
-        // No explicit RequestedChannel: the resolver picks the implicit channel only.
-        // We exercise the production codepath with a tracking packaging service so the
-        // assertion is that the resolver completes (no exception is thrown by
+        // No explicit RequestedChannel and the identity channel ("local") does not match any
+        // registered Explicit channel: the resolver falls back to the implicit channel only.
+        // This is the preserved-behavior path from before
+        // https://github.com/microsoft/aspire/issues/17596 — a "local" CLI without a matching
+        // local-build hive must not silently route DotNet templates through a stable feed
+        // it doesn't recognize. We exercise the production codepath with a tracking packaging
+        // service so the assertion is that the resolver completes (no exception is thrown by
         // an unexpected channel-lookup path) and only the implicit channel is in play.
         var requestedChannels = new List<PackageChannelType>();
         var packagingService = new TestPackagingService
@@ -247,6 +251,63 @@ public async Task ResolveTemplatePackageAsync_NullRequestedChannel_UsesImplicitC
             async () => await service.ResolveTemplatePackageAsync(query, CancellationToken.None));
     }
 
+    [Fact]
+    public async Task ResolveTemplatePackageAsync_NullRequestedChannel_PrefersIdentityChannelMatch()
+    {
+        // Regression test for https://github.com/microsoft/aspire/issues/17596: a daily CLI
+        // running `aspire new` for a DotNet template (e.g. C# Blazor) with no --channel flag
+        // and an empty ~/.aspire must resolve Aspire.ProjectTemplates from the daily channel,
+        // not from the implicit nuget.org channel. Previously this path restricted the search
+        // to the implicit channel only, so the latest shipped stable (e.g. 13.3.5) would mask
+        // the daily prerelease (e.g. 13.5.0-preview.1.*) that the matching CLI needs.
+        var packagingService = new TestPackagingService
+        {
+            GetChannelsAsyncCallback = _ =>
+            {
+                var implicitCh = PackageChannel.CreateImplicitChannel(new FakeNuGetPackageCache
+                {
+                    GetTemplatePackagesAsyncCallback = (_, _, _, _) => Task.FromResult<IEnumerable<Aspire.Shared.NuGetPackageCli>>(
+                    [
+                        new Aspire.Shared.NuGetPackageCli { Id = TemplateNuGetConfigService.TemplatesPackageName, Version = "13.3.5", Source = "nuget.org" }
+                    ])
+                }, new TestFeatures());
+                var dailyCh = PackageChannel.CreateExplicitChannel(
+                    "daily",
+                    PackageChannelQuality.Prerelease,
+                    [new PackageMapping("Aspire*", "daily-src")],
+                    new FakeNuGetPackageCache
+                    {
+                        GetTemplatePackagesAsyncCallback = (_, _, _, _) => Task.FromResult<IEnumerable<Aspire.Shared.NuGetPackageCli>>(
+                        [
+                            new Aspire.Shared.NuGetPackageCli { Id = TemplateNuGetConfigService.TemplatesPackageName, Version = "13.5.0-preview.1.26277.21", Source = "daily-src" }
+                        ])
+                    },
+                    features: new TestFeatures());
+                return Task.FromResult<IEnumerable<PackageChannel>>([implicitCh, dailyCh]);
+            }
+        };
+
+        var executionContext = TestExecutionContextHelper.CreateExecutionContext(
+            rootDirectory: new DirectoryInfo(Path.GetTempPath()),
+            identityChannel: "daily");
+
+        var service = CreateService(packagingService: packagingService, executionContext: executionContext);
+
+        var query = new TemplatePackageQuery(
+            RequestedChannel: null,
+            VersionOverride: null,
+            SourceOverride: null,
+            IncludePrHives: false);
+
+        var selection = await service.ResolveTemplatePackageAsync(query, CancellationToken.None);
+
+        // The daily channel must be selected (matches identity) and its prerelease package
+        // returned — not the stable 13.3.5 from the implicit channel.
+        Assert.Equal("daily", selection.Channel.Name);
+        Assert.Equal(PackageChannelType.Explicit, selection.Channel.Type);
+        Assert.Equal("13.5.0-preview.1.26277.21", selection.Package.Version);
+    }
+
     [Fact]
     public async Task ResolveTemplatePackage_RequestedChannel_NotFound_Throws()
     {