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.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,19 @@ 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);
+        var channelSources = await GetNuGetSourcesAsync(requestedChannel, packageSourceOverride, cancellationToken);
+        var projectContent = GenerateIntegrationProjectFile(
+            packageRefs,
+            projectRefs,
+            restoreDir,
+            channelSources,
+            useExactPackageVersions: !string.IsNullOrWhiteSpace(packageSourceOverride));
         var projectFilePath = Path.Combine(restoreDir, IntegrationProjectFileName);
         await File.WriteAllTextAsync(projectFilePath, projectContent, cancellationToken);
 
@@ -354,7 +368,8 @@ internal static string GenerateIntegrationProjectFile(
         List<IntegrationReference> packageRefs,
         List<IntegrationReference> projectRefs,
         string restoreDir,
-        IEnumerable<string>? additionalSources = null)
+        IEnumerable<string>? additionalSources = null,
+        bool useExactPackageVersions = false)
     {
         var propertyGroup = new XElement("PropertyGroup",
             new XElement("TargetFramework", DotNetBasedAppHostServerProject.TargetFramework),
@@ -394,7 +409,7 @@ internal static string GenerateIntegrationProjectFile(
                     }
                     return new XElement("PackageReference",
                         new XAttribute("Include", p.Name),
-                        new XAttribute("Version", p.Version));
+                        new XAttribute("Version", GetRestoreVersion(p.Version, useExactPackageVersions)));
                 })));
         }
 
@@ -461,26 +476,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 +508,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 +589,28 @@ 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 version, bool useExactPackageVersions)
+    {
+        if (!useExactPackageVersions || version.Length == 0 || version[0] is '[' or '(')
+        {
+            return version;
+        }
+
+        return $"[{version}]";
+    }
+
     /// <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(

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

@@ -18,6 +18,8 @@ namespace Aspire.Cli.Tests.Projects;
 
 public class PrebuiltAppHostServerTests(ITestOutputHelper outputHelper)
 {
+    private const string NuGetOrgSource = "https://api.nuget.org/v3/index.json";
+
     [Fact]
     public void GenerateIntegrationProjectFile_WithPackagesOnly_ProducesPackageReferences()
     {
@@ -484,7 +486,7 @@ private static PrebuiltAppHostServer CreateServerWithChannel(
             System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
         Assert.NotNull(method);
 
-        var task = (Task<TemporaryNuGetConfig?>)method.Invoke(server, [requestedChannel, CancellationToken.None])!;
+        var task = (Task<TemporaryNuGetConfig?>)method.Invoke(server, [requestedChannel, null, CancellationToken.None])!;
         return await task;
     }
 
@@ -589,6 +591,43 @@ public async Task PrepareAsync_WithPackageReferences_SetsOnlyPackageProbeManifes
         }
     }
 
+    [Fact]
+    public async Task PrepareAsync_WithPackageReferences_UsesPackageSourceOverride()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        const string packageSourceOverride = "/tmp/aspire-pr-hive/packages";
+        List<string>? restoreArgs = null;
+
+        var (server, executionFactory) = CreatePackageReferenceServer(workspace);
+        executionFactory.AssertionCallback = (args, _, _, _) =>
+        {
+            if (args is ["nuget", "restore", ..])
+            {
+                restoreArgs = [.. args];
+            }
+        };
+
+        var workingDirectory = GetWorkingDirectory(server);
+
+        try
+        {
+            var result = await server.PrepareAsync(
+                "13.4.0-pr.17141.gf142085f",
+                [IntegrationReference.FromPackage("Aspire.Hosting.CodeGeneration.TypeScript", "13.4.0-pr.17141.gf142085f")],
+                packageSourceOverride: packageSourceOverride);
+
+            Assert.True(result.Success);
+            Assert.NotNull(restoreArgs);
+            Assert.Equal([packageSourceOverride, NuGetOrgSource], GetSourceArguments(restoreArgs!));
+            Assert.Contains("Aspire.Hosting.CodeGeneration.TypeScript,[13.4.0-pr.17141.gf142085f]", restoreArgs!);
+            Assert.Contains("--nuget-config", restoreArgs!);
+        }
+        finally
+        {
+            DeleteWorkingDirectory(workingDirectory);
+        }
+    }
+
     [Fact]
     public async Task PrepareAsync_WithOnlyProjectReferences_SetsOnlyProjectLayout()
     {
@@ -1177,6 +1216,20 @@ private static string GetWorkingDirectory(PrebuiltAppHostServer server)
                 .GetValue(server));
     }
 
+    private static string[] GetSourceArguments(IReadOnlyList<string> args)
+    {
+        var sources = new List<string>();
+        for (var i = 0; i < args.Count - 1; i++)
+        {
+            if (args[i] == "--source")
+            {
+                sources.Add(args[i + 1]);
+            }
+        }
+
+        return [.. sources];
+    }
+
     private static void DeleteWorkingDirectory(string workingDirectory)
     {
         if (Directory.Exists(workingDirectory))