fix(cli): keep guest AppHost restore on the selected Aspire package source

src/Aspire.Cli/Projects/DotNetBasedAppHostServerProject.cs

@@ -417,7 +417,8 @@ private XDocument CreateProjectFile(IEnumerable<IntegrationReference> integratio
     public async Task<AppHostServerPrepareResult> PrepareAsync(
         string sdkVersion,
         IEnumerable<IntegrationReference> integrations,
-        CancellationToken cancellationToken = default)
+        CancellationToken cancellationToken = default,
+        string? packageSourceOverride = null)
     {
         var (_, channelName) = await CreateProjectFilesAsync(integrations, cancellationToken);
         var (buildSuccess, buildOutput) = await BuildAsync(cancellationToken);

src/Aspire.Cli/Projects/IAppHostServerProject.cs

@@ -41,11 +41,13 @@ internal interface IAppHostServerProject
     /// <param name="sdkVersion">The Aspire SDK version to use.</param>
     /// <param name="integrations">The integration references (NuGet packages and/or project references) required by the app host.</param>
     /// <param name="cancellationToken">Cancellation token.</param>
+    /// <param name="packageSourceOverride">Optional package source to prefer for Aspire package restore.</param>
     /// <returns>The preparation result indicating success/failure and any output.</returns>
     Task<AppHostServerPrepareResult> PrepareAsync(
         string sdkVersion,
         IEnumerable<IntegrationReference> integrations,
-        CancellationToken cancellationToken = default);
+        CancellationToken cancellationToken = default,
+        string? packageSourceOverride = null);
 
     /// <summary>
     /// Runs the AppHost server process.

src/Aspire.Cli/Projects/PrebuiltAppHostServer.cs

@@ -26,6 +26,8 @@ namespace Aspire.Cli.Projects;
 /// </summary>
 internal sealed class PrebuiltAppHostServer : IAppHostServerProject
 {
+    private const string NuGetOrgSource = "https://api.nuget.org/v3/index.json";
+
     internal const string ClosureMetadataFileName = "closure-metadata.txt";
     internal const string ClosureSourcesFileName = "closure-sources.txt";
     internal const string ClosureTargetsFileName = "closure-targets.txt";
@@ -123,7 +125,8 @@ public string GetServerPath()
     public async Task<AppHostServerPrepareResult> PrepareAsync(
         string sdkVersion,
         IEnumerable<IntegrationReference> integrations,
-        CancellationToken cancellationToken = default)
+        CancellationToken cancellationToken = default,
+        string? packageSourceOverride = null)
     {
         var integrationList = integrations.ToList();
         var packageRefs = integrationList.Where(r => r.IsPackageReference).ToList();
@@ -160,6 +163,7 @@ public async Task<AppHostServerPrepareResult> PrepareAsync(
                     packageRefs,
                     projectRefs,
                     requestedChannel,
+                    packageSourceOverride,
                     cancellationToken).ConfigureAwait(false);
 
                 if (closureManifest.Entries.Any(static entry => entry.IsPackageBacked))
@@ -185,7 +189,7 @@ await IntegrationPackageProbeManifest.WriteAsync(
                 {
                     // NuGet-only — use the bundled NuGet service (no SDK required)
                     _integrationProbeManifestPath = await RestoreNuGetPackagesAsync(
-                        packageRefs, requestedChannel, cancellationToken);
+                        packageRefs, requestedChannel, packageSourceOverride, cancellationToken);
                 }
 
                 var appSettingsContent = CreateAppSettingsContent(packageRefs, []);
@@ -226,13 +230,17 @@ await IntegrationPackageProbeManifest.WriteAsync(
     private async Task<string> RestoreNuGetPackagesAsync(
         List<IntegrationReference> packageRefs,
         string? requestedChannel,
+        string? packageSourceOverride,
         CancellationToken cancellationToken)
     {
         _logger.LogDebug("Restoring {Count} integration packages via bundled NuGet", packageRefs.Count);
 
-        var packages = packageRefs.Select(r => (r.Name, r.Version!)).ToList();
-        using var temporaryNuGetConfig = await TryCreateTemporaryNuGetConfigAsync(requestedChannel, cancellationToken);
-        var sources = await GetNuGetSourcesAsync(requestedChannel, cancellationToken);
+        var useExactPackageVersions = !string.IsNullOrWhiteSpace(packageSourceOverride);
+        var packages = packageRefs
+            .Select(r => (r.Name, Version: GetRestoreVersion(r.Name, r.Version!, useExactPackageVersions)))
+            .ToList();
+        using var temporaryNuGetConfig = await TryCreateTemporaryNuGetConfigAsync(requestedChannel, packageSourceOverride, cancellationToken);
+        var sources = await GetNuGetSourcesAsync(requestedChannel, packageSourceOverride, cancellationToken);
 
         return await _nugetService.RestorePackagesAsync(
             packages,
@@ -253,13 +261,23 @@ private async Task<AppHostServerClosureManifest> BuildIntegrationClosureManifest
         List<IntegrationReference> packageRefs,
         List<IntegrationReference> projectRefs,
         string? requestedChannel,
+        string? packageSourceOverride,
         CancellationToken cancellationToken)
     {
         var restoreDir = Path.Combine(_workingDirectory, "integration-restore");
         Directory.CreateDirectory(restoreDir);
 
-        var channelSources = await GetNuGetSourcesAsync(requestedChannel, cancellationToken);
-        var projectContent = GenerateIntegrationProjectFile(packageRefs, projectRefs, restoreDir, channelSources);
+        using var temporaryNuGetConfig = await TryCreateTemporaryNuGetConfigAsync(requestedChannel, packageSourceOverride, cancellationToken);
+        var channelSources = temporaryNuGetConfig is null
+            ? await GetNuGetSourcesAsync(requestedChannel, packageSourceOverride, cancellationToken)
+            : null;
+        var projectContent = GenerateIntegrationProjectFile(
+            packageRefs,
+            projectRefs,
+            restoreDir,
+            channelSources,
+            useExactPackageVersions: !string.IsNullOrWhiteSpace(packageSourceOverride),
+            restoreConfigFile: temporaryNuGetConfig?.ConfigFile.FullName);
         var projectFilePath = Path.Combine(restoreDir, IntegrationProjectFileName);
         await File.WriteAllTextAsync(projectFilePath, projectContent, cancellationToken);
 
@@ -354,7 +372,9 @@ internal static string GenerateIntegrationProjectFile(
         List<IntegrationReference> packageRefs,
         List<IntegrationReference> projectRefs,
         string restoreDir,
-        IEnumerable<string>? additionalSources = null)
+        IEnumerable<string>? additionalSources = null,
+        bool useExactPackageVersions = false,
+        string? restoreConfigFile = null)
     {
         var propertyGroup = new XElement("PropertyGroup",
             new XElement("TargetFramework", DotNetBasedAppHostServerProject.TargetFramework),
@@ -368,8 +388,12 @@ internal static string GenerateIntegrationProjectFile(
             new XElement("AspireClosureTargetsFile", Path.Combine(restoreDir, ClosureTargetsFileName)),
             new XElement("AspireProjectRefAssemblyNamesFile", Path.Combine(restoreDir, ProjectRefAssemblyNamesFileName)));
 
-        // Add channel sources without replacing the user's nuget.config
-        if (additionalSources is not null)
+        if (!string.IsNullOrWhiteSpace(restoreConfigFile))
+        {
+            propertyGroup.Add(new XElement("RestoreConfigFile", restoreConfigFile));
+        }
+        // Add channel sources without replacing the user's nuget.config.
+        else if (additionalSources is not null)
         {
             var sourceList = string.Join(";", additionalSources);
             if (sourceList.Length > 0)
@@ -394,7 +418,7 @@ internal static string GenerateIntegrationProjectFile(
                     }
                     return new XElement("PackageReference",
                         new XAttribute("Include", p.Name),
-                        new XAttribute("Version", p.Version));
+                        new XAttribute("Version", GetRestoreVersion(p.Name, p.Version, useExactPackageVersions)));
                 })));
         }
 
@@ -461,26 +485,18 @@ internal static string GenerateIntegrationProjectFile(
     /// <summary>
     /// Gets NuGet sources from the resolved channel for bundled restore.
     /// </summary>
-    private async Task<IEnumerable<string>?> GetNuGetSourcesAsync(string? requestedChannel, CancellationToken cancellationToken)
+    private async Task<IEnumerable<string>?> GetNuGetSourcesAsync(string? requestedChannel, string? packageSourceOverride, CancellationToken cancellationToken)
     {
         var sources = new List<string>();
 
-        try
+        if (!string.IsNullOrWhiteSpace(packageSourceOverride))
         {
-            var channels = await _packagingService.GetChannelsAsync(cancellationToken);
-
-            IEnumerable<PackageChannel> explicitChannels;
-            if (!string.IsNullOrEmpty(requestedChannel))
-            {
-                var matchingChannel = channels.FirstOrDefault(c => string.Equals(c.Name, requestedChannel, StringComparison.OrdinalIgnoreCase));
-                explicitChannels = matchingChannel is not null ? [matchingChannel] : channels.Where(c => c.Type == PackageChannelType.Explicit);
-            }
-            else
-            {
-                explicitChannels = channels.Where(c => c.Type == PackageChannelType.Explicit);
-            }
+            sources.Add(packageSourceOverride);
+        }
 
-            foreach (var channel in explicitChannels)
+        try
+        {
+            foreach (var channel in await GetExplicitRestoreChannelsAsync(requestedChannel, cancellationToken))
             {
                 if (channel.Mappings is null)
                 {
@@ -501,11 +517,52 @@ internal static string GenerateIntegrationProjectFile(
             _logger.LogWarning(ex, "Failed to get package channels, relying on nuget.config and nuget.org fallback");
         }
 
+        if (!string.IsNullOrWhiteSpace(packageSourceOverride) && sources.Count == 1)
+        {
+            sources.Add(NuGetOrgSource);
+        }
+
         return sources.Count > 0 ? sources : null;
     }
 
-    private async Task<TemporaryNuGetConfig?> TryCreateTemporaryNuGetConfigAsync(string? requestedChannel, CancellationToken cancellationToken)
+    private async Task<TemporaryNuGetConfig?> TryCreateTemporaryNuGetConfigAsync(string? requestedChannel, string? packageSourceOverride, CancellationToken cancellationToken)
     {
+        if (!string.IsNullOrWhiteSpace(packageSourceOverride))
+        {
+            var mappings = new List<PackageMapping>
+            {
+                new("Aspire*", packageSourceOverride)
+            };
+            var configureGlobalPackagesFolder = false;
+
+            try
+            {
+                foreach (var restoreChannel in await GetExplicitRestoreChannelsAsync(requestedChannel, cancellationToken))
+                {
+                    if (restoreChannel.Mappings is null)
+                    {
+                        continue;
+                    }
+
+                    mappings.AddRange(restoreChannel.Mappings);
+                    configureGlobalPackagesFolder |= restoreChannel.ConfigureGlobalPackagesFolder;
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to get package channels while creating source override NuGet.config");
+            }
+
+            if (!mappings.Any(static mapping => mapping.PackageFilter == PackageMapping.AllPackages))
+            {
+                mappings.Add(new PackageMapping(PackageMapping.AllPackages, NuGetOrgSource));
+            }
+
+            return await TemporaryNuGetConfig.CreateAsync(
+                [.. mappings.DistinctBy(static mapping => $"{mapping.PackageFilter}\0{mapping.Source}")],
+                configureGlobalPackagesFolder);
+        }
+
         if (string.IsNullOrEmpty(requestedChannel))
         {
             return null;
@@ -541,6 +598,33 @@ internal static string GenerateIntegrationProjectFile(
         return await TemporaryNuGetConfig.CreateAsync(channel.Mappings, channel.ConfigureGlobalPackagesFolder);
     }
 
+    private async Task<IEnumerable<PackageChannel>> GetExplicitRestoreChannelsAsync(string? requestedChannel, CancellationToken cancellationToken)
+    {
+        var channels = await _packagingService.GetChannelsAsync(cancellationToken);
+        if (!string.IsNullOrEmpty(requestedChannel))
+        {
+            var matchingChannel = channels.FirstOrDefault(c => string.Equals(c.Name, requestedChannel, StringComparison.OrdinalIgnoreCase));
+            return matchingChannel is not null ? [matchingChannel] : channels.Where(c => c.Type == PackageChannelType.Explicit).ToArray();
+        }
+
+        return channels.Where(c => c.Type == PackageChannelType.Explicit).ToArray();
+    }
+
+    private static string GetRestoreVersion(string packageName, string version, bool useExactPackageVersions)
+    {
+        if (!ShouldUseExactPackageVersion(packageName, useExactPackageVersions) || version.Length == 0 || version[0] is '[' or '(')
+        {
+            return version;
+        }
+
+        return $"[{version}]";
+    }
+
+    private static bool ShouldUseExactPackageVersion(string packageName, bool useExactPackageVersions)
+    {
+        return useExactPackageVersions && packageName.StartsWith("Aspire", StringComparison.OrdinalIgnoreCase);
+    }
+
     /// <inheritdoc />
     public (string SocketPath, Process Process, OutputCollector OutputCollector) Run(
         int hostPid,

src/Aspire.Cli/Scaffolding/IScaffoldingService.cs

@@ -13,12 +13,14 @@ namespace Aspire.Cli.Scaffolding;
 /// <param name="ProjectName">Optional project name.</param>
 /// <param name="SdkVersion">Optional Aspire SDK version to use for scaffolding.</param>
 /// <param name="Channel">Optional Aspire channel to use for scaffolding.</param>
+/// <param name="PackageSourceOverride">Optional package source to prefer when restoring scaffold/code-generation packages.</param>
 internal record ScaffoldContext(
     LanguageInfo Language,
     DirectoryInfo TargetDirectory,
     string? ProjectName = null,
     string? SdkVersion = null,
-    string? Channel = null);
+    string? Channel = null,
+    string? PackageSourceOverride = null);
 
 /// <summary>
 /// Service for scaffolding new AppHost projects.

src/Aspire.Cli/Scaffolding/ScaffoldingService.cs

@@ -97,7 +97,7 @@ private async Task<bool> ScaffoldGuestLanguageAsync(ScaffoldContext context, Can
 
         var prepareResult = await _interactionService.ShowStatusAsync(
             "Preparing Aspire server...",
-            () => appHostServerProject.PrepareAsync(prepareSdkVersion, integrations, cancellationToken),
+            () => appHostServerProject.PrepareAsync(prepareSdkVersion, integrations, cancellationToken, packageSourceOverride: context.PackageSourceOverride),
             emoji: KnownEmojis.Gear);
         if (!prepareResult.Success)
         {

src/Aspire.Cli/Templating/CliTemplateFactory.EmptyTemplate.cs

@@ -77,7 +77,8 @@ private async Task<TemplateResult> ApplyEmptyAppHostTemplateAsync(CallbackTempla
                             new DirectoryInfo(outputPath),
                             projectName,
                             SdkVersion: inputs.Version,
-                            Channel: inputs.Channel);
+                            Channel: inputs.Channel,
+                            PackageSourceOverride: inputs.Source);
                         if (!await _scaffoldingService.ScaffoldAsync(context, cancellationToken))
                         {
                             return new TemplateResult(ExitCodeConstants.FailedToCreateNewProject);

tests/Aspire.Cli.Tests/Projects/AppHostServerSessionTests.cs

@@ -49,7 +49,8 @@ private sealed class RecordingAppHostServerProject : IAppHostServerProject
         public Task<AppHostServerPrepareResult> PrepareAsync(
             string sdkVersion,
             IEnumerable<IntegrationReference> integrations,
-            CancellationToken cancellationToken = default) =>
+            CancellationToken cancellationToken = default,
+            string? packageSourceOverride = null) =>
             throw new NotSupportedException();
 
         public (string SocketPath, Process Process, OutputCollector OutputCollector) Run(