Add project reference support for polyglot apphost integrations

src/Aspire.Cli/Commands/Sdk/SdkDumpCommand.cs

@@ -122,39 +122,35 @@ private async Task<int> DumpCapabilitiesAsync(
 
         try
         {
-            // TODO: Support bundle mode by using DLL references instead of project references.
-            // In bundle mode, we'd need to add integration DLLs to the probing path rather than
-            // using additionalProjectReferences. For now, SDK dump only works with .NET SDK.
-            var appHostServerProjectInterface = await _appHostServerProjectFactory.CreateAsync(tempDir, cancellationToken);
-            if (appHostServerProjectInterface is not DotNetBasedAppHostServerProject appHostServerProject)
+            var appHostServerProject = await _appHostServerProjectFactory.CreateAsync(tempDir, cancellationToken);
+
+            // Build integrations list - optional integration project reference
+            var integrations = new List<IntegrationReference>();
+
+            if (integrationProject is not null)
             {
-                InteractionService.DisplayError("SDK dump is only available with .NET SDK installed.");
-                return ExitCodeConstants.FailedToBuildArtifacts;
+                integrations.Add(new IntegrationReference(
+                    Path.GetFileNameWithoutExtension(integrationProject.FullName),
+                    Version: null,
+                    ProjectPath: integrationProject.FullName));
             }
 
-            // Build packages list - empty since we only need core capabilities + optional integration
-            var packages = new List<(string Name, string Version)>();
-
             _logger.LogDebug("Building AppHost server for capability scanning");
 
-            // Create project files with the integration project reference if specified
-            var additionalProjectRefs = integrationProject is not null
-                ? new[] { integrationProject.FullName }
-                : null;
+            var prepareResult = await appHostServerProject.PrepareAsync(
+                VersionHelper.GetDefaultTemplateVersion(),
+                integrations,
+                cancellationToken);
 
-            await appHostServerProject.CreateProjectFilesAsync(
-                packages,
-                cancellationToken,
-                additionalProjectReferences: additionalProjectRefs);
-
-            var (buildSuccess, buildOutput) = await appHostServerProject.BuildAsync(cancellationToken);
-
-            if (!buildSuccess)
+            if (!prepareResult.Success)
             {
                 InteractionService.DisplayError("Failed to build capability scanner.");
-                foreach (var (_, line) in buildOutput.GetLines())
+                if (prepareResult.Output is not null)
                 {
-                    InteractionService.DisplayMessage(KnownEmojis.Wrench, line);
+                    foreach (var (_, line) in prepareResult.Output.GetLines())
+                    {
+                        InteractionService.DisplayMessage(KnownEmojis.Wrench, line);
+                    }
                 }
                 return ExitCodeConstants.FailedToBuildArtifacts;
             }

src/Aspire.Cli/Commands/Sdk/SdkGenerateCommand.cs

@@ -120,42 +120,41 @@ private async Task<int> GenerateSdkAsync(
 
         try
         {
-            // TODO: Support bundle mode by using DLL references instead of project references.
-            // In bundle mode, we'd need to add integration DLLs to the probing path rather than
-            // using additionalProjectReferences. For now, SDK generation only works with .NET SDK.
-            var appHostServerProjectInterface = await _appHostServerProjectFactory.CreateAsync(tempDir, cancellationToken);
-            if (appHostServerProjectInterface is not DotNetBasedAppHostServerProject appHostServerProject)
-            {
-                InteractionService.DisplayError("SDK generation is only available with .NET SDK installed.");
-                return ExitCodeConstants.FailedToBuildArtifacts;
-            }
+            var appHostServerProject = await _appHostServerProjectFactory.CreateAsync(tempDir, cancellationToken);
 
             // Get code generation package for the target language
             var codeGenPackage = await _languageDiscovery.GetPackageForLanguageAsync(languageInfo.LanguageId, cancellationToken);
 
-            // Build packages list - include the code generator
-            var packages = new List<(string Name, string Version)>();
+            // Build integrations list — the integration project brings Aspire.Hosting transitively;
+            // we only need to add the codegen package and the project reference itself.
+            var integrations = new List<IntegrationReference>();
             if (codeGenPackage is not null)
             {
-                packages.Add((codeGenPackage, DotNetBasedAppHostServerProject.DefaultSdkVersion));
+                integrations.Add(new IntegrationReference(codeGenPackage, VersionHelper.GetDefaultTemplateVersion(), ProjectPath: null));
             }
 
-            _logger.LogDebug("Building AppHost server for SDK generation");
+            // Add the integration project as a project reference
+            integrations.Add(new IntegrationReference(
+                Path.GetFileNameWithoutExtension(integrationProject.FullName),
+                Version: null,
+                ProjectPath: integrationProject.FullName));
 
-            // Create project files with the integration project reference
-            await appHostServerProject.CreateProjectFilesAsync(
-                packages,
-                cancellationToken,
-                additionalProjectReferences: [integrationProject.FullName]);
+            _logger.LogDebug("Building AppHost server for SDK generation");
 
-            var (buildSuccess, buildOutput) = await appHostServerProject.BuildAsync(cancellationToken);
+            var prepareResult = await appHostServerProject.PrepareAsync(
+                VersionHelper.GetDefaultTemplateVersion(),
+                integrations,
+                cancellationToken);
 
-            if (!buildSuccess)
+            if (!prepareResult.Success)
             {
                 InteractionService.DisplayError("Failed to build SDK generation server.");
-                foreach (var (_, line) in buildOutput.GetLines())
+                if (prepareResult.Output is not null)
                 {
-                    InteractionService.DisplayMessage(KnownEmojis.Wrench, line);
+                    foreach (var (_, line) in prepareResult.Output.GetLines())
+                    {
+                        InteractionService.DisplayMessage(KnownEmojis.Wrench, line);
+                    }
                 }
                 return ExitCodeConstants.FailedToBuildArtifacts;
             }

src/Aspire.Cli/Configuration/AspireJsonConfiguration.cs

@@ -172,24 +172,27 @@ public string GetEffectiveSdkVersion(string defaultSdkVersion)
     }
 
     /// <summary>
-    /// Gets all package references including the base Aspire.Hosting package.
-    /// Empty package versions in settings are resolved to the effective SDK version.
+    /// Gets all integration references (both NuGet packages and project references)
+    /// including the base Aspire.Hosting package.
+    /// A value ending in ".csproj" is treated as a project reference; otherwise as a NuGet version.
+    /// Empty package versions are resolved to the effective SDK version.
     /// </summary>
     /// <param name="defaultSdkVersion">Default SDK version to use when not configured.</param>
-    /// <returns>Enumerable of (PackageName, Version) tuples.</returns>
-    public IEnumerable<(string Name, string Version)> GetAllPackages(string defaultSdkVersion)
+    /// <param name="settingsDirectory">The directory containing .aspire/settings.json, used to resolve relative project paths.</param>
+    /// <returns>Enumerable of IntegrationReference objects.</returns>
+    public IEnumerable<IntegrationReference> GetIntegrationReferences(string defaultSdkVersion, string settingsDirectory)
     {
         var sdkVersion = GetEffectiveSdkVersion(defaultSdkVersion);
 
-        // Base package always included (Aspire.Hosting.AppHost is an SDK, not a runtime DLL)
-        yield return ("Aspire.Hosting", sdkVersion);
+        // Base package always included
+        yield return new IntegrationReference("Aspire.Hosting", sdkVersion, ProjectPath: null);
 
         if (Packages is null)
         {
             yield break;
         }
 
-        foreach (var (packageName, version) in Packages)
+        foreach (var (packageName, value) in Packages)
         {
             // Skip base packages and SDK-only packages
             if (string.Equals(packageName, "Aspire.Hosting", StringComparison.OrdinalIgnoreCase) ||
@@ -198,21 +201,27 @@ public string GetEffectiveSdkVersion(string defaultSdkVersion)
                 continue;
             }
 
-            yield return (packageName, string.IsNullOrWhiteSpace(version) ? sdkVersion : version);
+            var trimmedValue = value?.Trim();
+
+            if (string.IsNullOrEmpty(trimmedValue))
+            {
+                // NuGet package reference with no explicit version — fall back to the SDK version
+                yield return new IntegrationReference(packageName, sdkVersion, ProjectPath: null);
+                continue;
+            }
+
+            if (trimmedValue.EndsWith(".csproj", StringComparison.OrdinalIgnoreCase))
+            {
+                // Project reference — resolve relative path to absolute
+                var absolutePath = Path.GetFullPath(Path.Combine(settingsDirectory, trimmedValue));
+                yield return new IntegrationReference(packageName, Version: null, ProjectPath: absolutePath);
+            }
+            else
+            {
+                // NuGet package reference with explicit version
+                yield return new IntegrationReference(packageName, trimmedValue, ProjectPath: null);
+            }
         }
     }
 
-    /// <summary>
-    /// Gets all package references including the base Aspire.Hosting packages.
-    /// Uses the SdkVersion for base packages.
-    /// Note: Aspire.Hosting.AppHost is an SDK package (not a runtime DLL) and is excluded.
-    /// </summary>
-    /// <returns>Enumerable of (PackageName, Version) tuples.</returns>
-    public IEnumerable<(string Name, string Version)> GetAllPackages()
-    {
-        var sdkVersion = !string.IsNullOrWhiteSpace(SdkVersion)
-            ? SdkVersion
-            : throw new InvalidOperationException("SdkVersion must be set to a non-empty value before calling GetAllPackages. Use LoadOrCreate to ensure it's set.");
-        return GetAllPackages(sdkVersion);
-    }
 }

src/Aspire.Cli/Configuration/IntegrationReference.cs

@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Aspire.Cli.Configuration;
+
+/// <summary>
+/// Represents a reference to an Aspire hosting integration, which can be either
+/// a NuGet package (with a version) or a local project reference (with a path to a .csproj).
+/// </summary>
+/// <param name="Name">The package or assembly name (e.g., "Aspire.Hosting.Redis").</param>
+/// <param name="Version">The NuGet package version, or null for project references.</param>
+/// <param name="ProjectPath">The absolute path to the .csproj file, or null for NuGet packages.</param>
+internal sealed record IntegrationReference(string Name, string? Version, string? ProjectPath)
+{
+    /// <summary>
+    /// Returns true if this is a project reference (has a .csproj path).
+    /// </summary>
+    public bool IsProjectReference => ProjectPath is not null;
+
+    /// <summary>
+    /// Returns true if this is a NuGet package reference (has a version).
+    /// </summary>
+    public bool IsPackageReference => Version is not null;
+}

src/Aspire.Cli/Projects/AppHostServerProject.cs

@@ -31,6 +31,7 @@ internal sealed class AppHostServerProjectFactory(
     IConfigurationService configurationService,
     IBundleService bundleService,
     BundleNuGetService bundleNuGetService,
+    IDotNetSdkInstaller sdkInstaller,
     ILoggerFactory loggerFactory) : IAppHostServerProjectFactory
 {
     public async Task<IAppHostServerProject> CreateAsync(string appPath, CancellationToken cancellationToken = default)
@@ -83,6 +84,8 @@ public async Task<IAppHostServerProject> CreateAsync(string appPath, Cancellatio
                 socketPath,
                 layout,
                 bundleNuGetService,
+                dotNetCliRunner,
+                sdkInstaller,
                 packagingService,
                 configurationService,
                 loggerFactory.CreateLogger<PrebuiltAppHostServer>());

src/Aspire.Cli/Projects/AppHostServerSession.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
+using Aspire.Cli.Configuration;
 using Aspire.Cli.Utils;
 using Microsoft.Extensions.Logging;
 
@@ -100,15 +101,15 @@ public AppHostServerSessionFactory(
     public async Task<AppHostServerSessionResult> CreateAsync(
         string appHostPath,
         string sdkVersion,
-        IEnumerable<(string PackageId, string Version)> packages,
+        IEnumerable<IntegrationReference> integrations,
         Dictionary<string, string>? launchSettingsEnvVars,
         bool debug,
         CancellationToken cancellationToken)
     {
         var appHostServerProject = await _projectFactory.CreateAsync(appHostPath, cancellationToken);
 
         // Prepare the server (create files + build for dev mode, restore packages for prebuilt mode)
-        var prepareResult = await appHostServerProject.PrepareAsync(sdkVersion, packages, cancellationToken);
+        var prepareResult = await appHostServerProject.PrepareAsync(sdkVersion, integrations, cancellationToken);
         if (!prepareResult.Success)
         {
             return new AppHostServerSessionResult(

src/Aspire.Cli/Projects/DotNetBasedAppHostServerProject.cs

@@ -135,7 +135,7 @@ public void SaveProjectHash(string hash)
     /// <summary>
     /// Creates the project .csproj content using project references to the local Aspire repository.
     /// </summary>
-    private XDocument CreateProjectFile(IEnumerable<(string Name, string Version)> packages)
+    private XDocument CreateProjectFile(IEnumerable<IntegrationReference> integrations)
     {
         // Determine OS/architecture for DCP package name
         var (buildOs, buildArch) = GetBuildPlatform();
@@ -183,12 +183,22 @@ private XDocument CreateProjectFile(IEnumerable<(string Name, string Version)> p
         var addedProjects = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
         var otherPackages = new List<(string Name, string Version)>();
 
-        foreach (var (name, version) in packages)
+        foreach (var integration in integrations)
         {
-            if (name.StartsWith("Aspire.Hosting", StringComparison.OrdinalIgnoreCase))
+            if (integration.IsProjectReference)
             {
-                var projectPath = Path.Combine(_repoRoot, "src", name, $"{name}.csproj");
-                if (File.Exists(projectPath) && addedProjects.Add(name))
+                // Explicit project reference from settings.json
+                if (addedProjects.Add(integration.Name))
+                {
+                    projectRefGroup.Add(new XElement("ProjectReference",
+                        new XAttribute("Include", integration.ProjectPath!),
+                        new XElement("IsAspireProjectResource", "false")));
+                }
+            }
+            else if (integration.Name.StartsWith("Aspire.Hosting", StringComparison.OrdinalIgnoreCase))
+            {
+                var projectPath = Path.Combine(_repoRoot, "src", integration.Name, $"{integration.Name}.csproj");
+                if (File.Exists(projectPath) && addedProjects.Add(integration.Name))
                 {
                     projectRefGroup.Add(new XElement("ProjectReference",
                         new XAttribute("Include", projectPath),
@@ -197,7 +207,7 @@ private XDocument CreateProjectFile(IEnumerable<(string Name, string Version)> p
             }
             else
             {
-                otherPackages.Add((name, version));
+                otherPackages.Add((integration.Name, integration.Version!));
             }
         }
 
@@ -262,9 +272,8 @@ private XDocument CreateProjectFile(IEnumerable<(string Name, string Version)> p
     /// Scaffolds the project files.
     /// </summary>
     public async Task<(string ProjectPath, string? ChannelName)> CreateProjectFilesAsync(
-        IEnumerable<(string Name, string Version)> packages,
-        CancellationToken cancellationToken = default,
-        IEnumerable<string>? additionalProjectReferences = null)
+        IEnumerable<IntegrationReference> integrations,
+        CancellationToken cancellationToken = default)
     {
         // Clean obj folder to ensure fresh NuGet restore
         var objPath = Path.Combine(_projectModelPath, "obj");
@@ -288,23 +297,18 @@ private XDocument CreateProjectFile(IEnumerable<(string Name, string Version)> p
 
         // Create appsettings.json with ATS assemblies
         var atsAssemblies = new List<string> { "Aspire.Hosting" };
-        foreach (var pkg in packages)
+        foreach (var integration in integrations)
         {
-            if (!atsAssemblies.Contains(pkg.Name, StringComparer.OrdinalIgnoreCase))
+            // Skip SDK-only packages that don't produce runtime assemblies
+            if (integration.Name.Equals("Aspire.Hosting.AppHost", StringComparison.OrdinalIgnoreCase) ||
+                integration.Name.StartsWith("Aspire.AppHost.Sdk", StringComparison.OrdinalIgnoreCase))
             {
-                atsAssemblies.Add(pkg.Name);
+                continue;
             }
-        }
 
-        if (additionalProjectReferences is not null)
-        {
-            foreach (var projectPath in additionalProjectReferences)
+            if (!atsAssemblies.Contains(integration.Name, StringComparer.OrdinalIgnoreCase))
             {
-                var assemblyName = Path.GetFileNameWithoutExtension(projectPath);
-                if (!atsAssemblies.Contains(assemblyName, StringComparer.OrdinalIgnoreCase))
-                {
-                    atsAssemblies.Add(assemblyName);
-                }
+                atsAssemblies.Add(integration.Name);
             }
         }
 
@@ -364,22 +368,7 @@ await NuGetConfigMerger.CreateOrUpdateAsync(
         }
 
         // Create the project file
-        var doc = CreateProjectFile(packages);
-
-        // Add additional project references
-        if (additionalProjectReferences is not null)
-        {
-            var additionalProjectRefs = additionalProjectReferences
-                .Select(path => new XElement("ProjectReference",
-                    new XAttribute("Include", path),
-                    new XElement("IsAspireProjectResource", "false")))
-                .ToList();
-
-            if (additionalProjectRefs.Count > 0)
-            {
-                doc.Root!.Add(new XElement("ItemGroup", additionalProjectRefs));
-            }
-        }
+        var doc = CreateProjectFile(integrations);
 
         // Add appsettings.json to output
         doc.Root!.Add(new XElement("ItemGroup",
@@ -433,10 +422,10 @@ await NuGetConfigMerger.CreateOrUpdateAsync(
     /// <inheritdoc />
     public async Task<AppHostServerPrepareResult> PrepareAsync(
         string sdkVersion,
-        IEnumerable<(string Name, string Version)> packages,
+        IEnumerable<IntegrationReference> integrations,
         CancellationToken cancellationToken = default)
     {
-        var (_, channelName) = await CreateProjectFilesAsync(packages, cancellationToken);
+        var (_, channelName) = await CreateProjectFilesAsync(integrations, cancellationToken);
         var (buildSuccess, buildOutput) = await BuildAsync(cancellationToken);
 
         if (!buildSuccess)