Replace sync-over-async runtime resolution with IContainerRuntimeResolver

Introduce IContainerRuntimeResolver with async ResolveAsync() that
caches the result. This eliminates the .GetAwaiter().GetResult() call
in the DI singleton factory that blocked the thread during startup
while probing container runtimes.

Callers now resolve IContainerRuntimeResolver and await ResolveAsync()
instead of resolving IContainerRuntime directly. This is a breaking
change for the experimental IContainerRuntime API surface.

Also consolidates version detection into ContainerRuntimeDetector
(AOT-friendly JsonDocument parsing), adds FindBestRuntime() for
reuse without re-probing, and slims ContainerRuntimeCheck to pure
policy checks with no process spawning.

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

Author: davidfowl

src/Aspire.Cli/JsonSourceGenerationContext.cs

@@ -27,7 +27,6 @@ namespace Aspire.Cli;
 [JsonSerializable(typeof(DoctorCheckResponse))]
 [JsonSerializable(typeof(EnvironmentCheckResult))]
 [JsonSerializable(typeof(DoctorCheckSummary))]
-[JsonSerializable(typeof(ContainerVersionJson))]
 [JsonSerializable(typeof(AspireJsonConfiguration))]
 [JsonSerializable(typeof(AspireConfigFile))]
 [JsonSerializable(typeof(List<DevCertInfo>))]

src/Aspire.Cli/Utils/EnvironmentChecker/ContainerRuntimeCheck.cs

@@ -26,7 +26,7 @@ internal sealed class AcrLoginService : IAcrLoginService
     };
 
     private readonly IHttpClientFactory _httpClientFactory;
-    private readonly IContainerRuntime _containerRuntime;
+    private readonly IContainerRuntimeResolver _containerRuntimeResolver;
     private readonly ILogger<AcrLoginService> _logger;
 
     private sealed class AcrRefreshTokenResponse
@@ -42,12 +42,12 @@ private sealed class AcrRefreshTokenResponse
     /// Initializes a new instance of the <see cref="AcrLoginService"/> class.
     /// </summary>
     /// <param name="httpClientFactory">The HTTP client factory for making OAuth2 exchange requests.</param>
-    /// <param name="containerRuntime">The container runtime for performing registry login.</param>
+    /// <param name="containerRuntimeResolver">The container runtime resolver for performing registry login.</param>
     /// <param name="logger">The logger for diagnostic output.</param>
-    public AcrLoginService(IHttpClientFactory httpClientFactory, IContainerRuntime containerRuntime, ILogger<AcrLoginService> logger)
+    public AcrLoginService(IHttpClientFactory httpClientFactory, IContainerRuntimeResolver containerRuntimeResolver, ILogger<AcrLoginService> logger)
     {
         _httpClientFactory = httpClientFactory ?? throw new ArgumentNullException(nameof(httpClientFactory));
-        _containerRuntime = containerRuntime ?? throw new ArgumentNullException(nameof(containerRuntime));
+        _containerRuntimeResolver = containerRuntimeResolver ?? throw new ArgumentNullException(nameof(containerRuntimeResolver));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
     }
 
@@ -76,7 +76,8 @@ public async Task LoginAsync(
         _logger.LogDebug("ACR refresh token acquired, length: {TokenLength}", refreshToken.Length);
 
         // Step 3: Login to the registry using container runtime
-        await _containerRuntime.LoginToRegistryAsync(registryEndpoint, AcrUsername, refreshToken, cancellationToken).ConfigureAwait(false);
+        var containerRuntime = await _containerRuntimeResolver.ResolveAsync(cancellationToken).ConfigureAwait(false);
+        await containerRuntime.LoginToRegistryAsync(registryEndpoint, AcrUsername, refreshToken, cancellationToken).ConfigureAwait(false);
     }
 
     private async Task<string> ExchangeAadTokenForAcrRefreshTokenAsync(

src/Aspire.Hosting.Azure/AcrLoginService.cs

@@ -223,7 +223,7 @@ private async Task DockerComposeUpAsync(PipelineStepContext context)
             throw new InvalidOperationException($"Docker Compose file not found at {dockerComposeFilePath}");
         }
 
-        var runtime = context.Services.GetRequiredService<IContainerRuntime>();
+        var runtime = await context.Services.GetRequiredService<IContainerRuntimeResolver>().ResolveAsync(context.CancellationToken).ConfigureAwait(false);
 
         var deployTask = await context.ReportingStep.CreateTaskAsync(
             new MarkdownString($"Running compose up for **{Name}** using **{runtime.Name}**"),
@@ -259,7 +259,7 @@ private async Task DockerComposeDownAsync(PipelineStepContext context)
             throw new InvalidOperationException($"Docker Compose file not found at {dockerComposeFilePath}");
         }
 
-        var runtime = context.Services.GetRequiredService<IContainerRuntime>();
+        var runtime = await context.Services.GetRequiredService<IContainerRuntimeResolver>().ResolveAsync(context.CancellationToken).ConfigureAwait(false);
 
         var deployTask = await context.ReportingStep.CreateTaskAsync(
             new MarkdownString($"Running compose down for **{Name}** using **{runtime.Name}**"),

src/Aspire.Hosting.Docker/DockerComposeEnvironmentResource.cs

@@ -335,7 +335,7 @@ private async Task PrintEndpointsAsync(PipelineStepContext context, DockerCompos
         }
 
         // Query the running containers for published ports
-        var runtime = context.Services.GetRequiredService<IContainerRuntime>();
+        var runtime = await context.Services.GetRequiredService<IContainerRuntimeResolver>().ResolveAsync(context.CancellationToken).ConfigureAwait(false);
         var composeContext = environment.CreateComposeOperationContext(context);
         var services = await runtime.ComposeListServicesAsync(composeContext, context.CancellationToken).ConfigureAwait(false);
 

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

@@ -144,7 +144,7 @@ private async Task BuildProjectImage(PipelineStepContext ctx)
         var tempTag = $"temp-{Guid.NewGuid():N}";
         var tempImageName = $"{originalImageName}:{tempTag}";
 
-        var containerRuntime = ctx.Services.GetRequiredService<IContainerRuntime>();
+        var containerRuntime = await ctx.Services.GetRequiredService<IContainerRuntimeResolver>().ResolveAsync(ctx.CancellationToken).ConfigureAwait(false);
 
         logger.LogDebug("Tagging image {OriginalImageName} as {TempImageName}", originalImageName, tempImageName);
         await containerRuntime.TagImageAsync(originalImageName, tempImageName, ctx.CancellationToken).ConfigureAwait(false);

src/Aspire.Hosting/ApplicationModel/ProjectResource.cs

@@ -511,38 +511,7 @@ public DistributedApplicationBuilder(DistributedApplicationOptions options)
         Eventing.Subscribe<BeforeStartEvent>(BuiltInDistributedApplicationEventSubscriptionHandlers.MutateHttp2TransportAsync);
         _innerBuilder.Services.AddKeyedSingleton<IContainerRuntime, DockerContainerRuntime>("docker");
         _innerBuilder.Services.AddKeyedSingleton<IContainerRuntime, PodmanContainerRuntime>("podman");
-        _innerBuilder.Services.AddSingleton(sp =>
-        {
-            var dcpOptions = sp.GetRequiredService<IOptions<DcpOptions>>();
-            var logger = sp.GetRequiredService<ILoggerFactory>().CreateLogger("Aspire.Hosting.ContainerRuntime");
-            var configuredRuntime = dcpOptions.Value.ContainerRuntime;
-
-            if (configuredRuntime is not null)
-            {
-                logger.LogInformation("Container runtime '{RuntimeKey}' configured via ASPIRE_CONTAINER_RUNTIME.", configuredRuntime);
-                return sp.GetRequiredKeyedService<IContainerRuntime>(configuredRuntime);
-            }
-
-            // Auto-detect: probe available runtimes, matching DCP's detection logic.
-            // See https://github.com/microsoft/dcp/blob/main/internal/containers/runtimes/runtime.go
-            var detected = ContainerRuntimeDetector.FindAvailableRuntimeAsync().GetAwaiter().GetResult();
-            var runtimeKey = detected?.Executable ?? "docker";
-
-            if (detected is { IsHealthy: true })
-            {
-                logger.LogInformation("Container runtime auto-detected: {RuntimeName} ({Executable}).", detected.Name, detected.Executable);
-            }
-            else if (detected is { IsInstalled: true })
-            {
-                logger.LogWarning("Container runtime '{RuntimeName}' is installed but not running. {Error}", detected.Name, detected.Error);
-            }
-            else
-            {
-                logger.LogWarning("No container runtime detected, defaulting to 'docker'. Install Docker or Podman to use container features.");
-            }
-
-            return sp.GetRequiredKeyedService<IContainerRuntime>(runtimeKey);
-        });
+        _innerBuilder.Services.AddSingleton<IContainerRuntimeResolver, ContainerRuntimeResolver>();
         _innerBuilder.Services.AddSingleton<IResourceContainerImageManager, ResourceContainerImageManager>();
         _innerBuilder.Services.AddSingleton<PipelineActivityReporter>();
         _innerBuilder.Services.AddSingleton<IPipelineActivityReporter, PipelineActivityReporter>(sp => sp.GetRequiredService<PipelineActivityReporter>());

src/Aspire.Hosting/DistributedApplicationBuilder.cs

@@ -84,7 +84,7 @@ private static async Task TagImageForLocalRegistryAsync(IResource resource, Pipe
                     : resource.Name.ToLowerInvariant();
 
                 // Only tag the image, don't push to a remote registry
-                var containerRuntime = context.Services.GetRequiredService<IContainerRuntime>();
+                var containerRuntime = await context.Services.GetRequiredService<IContainerRuntimeResolver>().ResolveAsync(context.CancellationToken).ConfigureAwait(false);
                 await containerRuntime.TagImageAsync(localImageName, targetTag, context.CancellationToken).ConfigureAwait(false);
 
                 await tagTask.CompleteAsync(

src/Aspire.Hosting/Pipelines/PipelineStepHelpers.cs

@@ -0,0 +1,70 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable ASPIRECONTAINERRUNTIME001
+
+using Aspire.Hosting.Dcp;
+using Aspire.Shared;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace Aspire.Hosting.Publishing;
+
+/// <summary>
+/// Resolves the container runtime asynchronously using explicit configuration or auto-detection.
+/// Caches the result after first resolution.
+/// </summary>
+internal sealed class ContainerRuntimeResolver : IContainerRuntimeResolver
+{
+    private readonly IServiceProvider _serviceProvider;
+    private readonly IOptions<DcpOptions> _dcpOptions;
+    private readonly ILogger _logger;
+    private Task<IContainerRuntime>? _cachedTask;
+
+    public ContainerRuntimeResolver(
+        IServiceProvider serviceProvider,
+        IOptions<DcpOptions> dcpOptions,
+        ILoggerFactory loggerFactory)
+    {
+        _serviceProvider = serviceProvider;
+        _dcpOptions = dcpOptions;
+        _logger = loggerFactory.CreateLogger("Aspire.Hosting.ContainerRuntime");
+    }
+
+    public Task<IContainerRuntime> ResolveAsync(CancellationToken cancellationToken = default)
+    {
+        return _cachedTask ??= ResolveInternalAsync(cancellationToken);
+    }
+
+    private async Task<IContainerRuntime> ResolveInternalAsync(CancellationToken cancellationToken)
+    {
+        var configuredRuntime = _dcpOptions.Value.ContainerRuntime;
+
+        if (configuredRuntime is not null)
+        {
+            _logger.LogInformation("Container runtime '{RuntimeKey}' configured via ASPIRE_CONTAINER_RUNTIME.", configuredRuntime);
+            return _serviceProvider.GetRequiredKeyedService<IContainerRuntime>(configuredRuntime);
+        }
+
+        // Auto-detect: probe available runtimes asynchronously.
+        // See https://github.com/microsoft/dcp/blob/main/internal/containers/runtimes/runtime.go
+        var detected = await ContainerRuntimeDetector.FindAvailableRuntimeAsync(logger: _logger, cancellationToken: cancellationToken).ConfigureAwait(false);
+        var runtimeKey = detected?.Executable ?? "docker";
+
+        if (detected is { IsHealthy: true })
+        {
+            _logger.LogInformation("Container runtime auto-detected: {RuntimeName} ({Executable}).", detected.Name, detected.Executable);
+        }
+        else if (detected is { IsInstalled: true })
+        {
+            _logger.LogWarning("Container runtime '{RuntimeName}' is installed but not running. {Error}", detected.Name, detected.Error);
+        }
+        else
+        {
+            _logger.LogWarning("No container runtime detected, defaulting to 'docker'. Install Docker or Podman to use container features.");
+        }
+
+        return _serviceProvider.GetRequiredKeyedService<IContainerRuntime>(runtimeKey);
+    }
+}

src/Aspire.Hosting/Publishing/ContainerRuntimeResolver.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Aspire.Hosting.Publishing;
+
+/// <summary>
+/// Resolves the configured or auto-detected container runtime asynchronously.
+/// The result is cached after the first resolution.
+/// </summary>
+[Experimental("ASPIRECONTAINERRUNTIME001", UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
+public interface IContainerRuntimeResolver
+{
+    /// <summary>
+    /// Resolves the container runtime, detecting it from the environment if not explicitly configured.
+    /// The result is cached after the first call.
+    /// </summary>
+    /// <param name="cancellationToken">A token to cancel the operation.</param>
+    /// <returns>The resolved container runtime.</returns>
+    Task<IContainerRuntime> ResolveAsync(CancellationToken cancellationToken = default);
+}