Expose resolved environment variables to debug launch producers

src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs

@@ -107,23 +107,77 @@ public static bool HasLaunchToolArgsOwnedBy(this IResource resource, SupportsDeb
     /// <para>
     /// Launch configuration is created by invoking the producer callback passed to
     /// <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string)"/>
-    /// (or its asynchronous overload),
-    /// which owns the complete configuration; Aspire serializes the result as-is. 
-    /// The configuration is produced fresh on each call; it is not a singleton.
-    /// Aspire may call the producer several times for the same resource.
+    /// (or one of its asynchronous overloads), which owns the complete configuration; Aspire serializes the result as-is.
+    /// The configuration is produced fresh on each call.
     /// </para>
     /// <para>
-    /// This describes the launch configuration itself, not whether one is going to be used. 
-    /// Depending on how the application is started, or how a resource is configured,
-    /// Aspire may or may not run the resource under a debugger. Use <see cref="SupportsDebugging"/> to test for that.
+    /// This inspection API does not resolve the resource's environment variables. A producer that accepts a
+    /// <see cref="LaunchConfigurationCallbackContext"/> receives an empty
+    /// <see cref="LaunchConfigurationCallbackContext.EnvironmentVariables"/> collection. Aspire invokes that producer
+    /// separately with resolved values when it creates the executable.
+    /// </para>
+    /// <para>
+    /// This describes the launch configuration itself, not whether one is going to be used. Depending on how the
+    /// application is started or how a resource is configured, Aspire may or may not run the resource under a debugger.
+    /// Use <see cref="SupportsDebugging"/> to test for that.
     /// </para>
     /// </remarks>
     [AspireExportIgnore(Reason = "Debug support inspection is a local .NET helper and is not part of the ATS surface.")]
-    public static Task<object> CreateLaunchConfigurationAsync(this IResource resource, string mode, CancellationToken cancellationToken = default)
+    public static Task<object> CreateLaunchConfigurationAsync(
+        this IResource resource,
+        string mode,
+        CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(resource);
         ArgumentNullException.ThrowIfNull(mode);
 
+        var context = new LaunchConfigurationCallbackContext(
+            mode,
+            resource,
+            new Dictionary<string, string>(),
+            cancellationToken);
+
+        return resource.CreateLaunchConfigurationAsync(context);
+    }
+
+    /// <summary>
+    /// Creates the launch configuration that this resource sends to the IDE using a callback context.
+    /// </summary>
+    /// <param name="resource">The resource to inspect. It must carry a <see cref="SupportsDebuggingAnnotation"/>.</param>
+    /// <param name="context">The callback context containing the resolved environment and launch data.</param>
+    /// <returns>The launch configuration, typically an <see cref="ExecutableLaunchConfiguration"/>.</returns>
+    /// <exception cref="ArgumentException"><paramref name="context"/> belongs to a different resource.</exception>
+    /// <exception cref="InvalidOperationException">The resource does not declare debug launch support.</exception>
+    /// <remarks>
+    /// <para>
+    /// Launch configuration is created by invoking the producer callback passed to
+    /// <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{LaunchConfigurationCallbackContext, Task{TLaunchConfiguration}}, string)"/>,
+    /// which owns the complete configuration; Aspire serializes the result as-is.
+    /// </para>
+    /// <para>
+    /// This method never resolves environment variables. Aspire creates <paramref name="context"/>
+    /// when the active debug-support annotation is producing a launch configuration for an executable creation.
+    /// </para>
+    /// <para>
+    /// This overload is internal because only Aspire constructs callback contexts containing resolved environment
+    /// variables. Use the public overload when inspecting a launch configuration outside executable creation.
+    /// </para>
+    /// </remarks>
+    internal static Task<object> CreateLaunchConfigurationAsync(
+        this IResource resource,
+        LaunchConfigurationCallbackContext context)
+    {
+        ArgumentNullException.ThrowIfNull(resource);
+        ArgumentNullException.ThrowIfNull(context);
+
+        if (!ReferenceEquals(resource, context.Resource))
+        {
+            throw new ArgumentException(
+                $"The launch configuration callback context belongs to resource '{context.Resource.Name}', " +
+                $"but launch configuration was requested for resource '{resource.Name}'.",
+                nameof(context));
+        }
+
         if (!resource.TryGetLastAnnotation<SupportsDebuggingAnnotation>(out var supportsDebuggingAnnotation))
         {
             throw new InvalidOperationException(
@@ -132,7 +186,7 @@ public static Task<object> CreateLaunchConfigurationAsync(this IResource resourc
                 $"Note that it only adds the annotation in run mode.");
         }
 
-        return supportsDebuggingAnnotation.LaunchConfigurationProducer(mode, cancellationToken);
+        return supportsDebuggingAnnotation.LaunchConfigurationProducer(context);
     }
 
     private static string[]? GetSupportedLaunchConfigurations(IConfiguration configuration)

src/Aspire.Hosting/ApplicationModel/ExecutableLaunchConfiguration.cs

@@ -60,8 +60,7 @@ public static class KnownLaunchConfigurationTypes
 /// </para>
 /// <para>
 /// Integrations create a derived type and supply it through
-/// <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string)"/>
-/// or its asynchronous overload.
+/// one of the <c>WithDebugSupport</c> overloads on <see cref="ResourceBuilderExtensions"/>.
 /// </para>
 /// </remarks>
 /// <param name="type">The launch configuration type identifier, for example <see cref="KnownLaunchConfigurationTypes.Project"/>.</param>
@@ -90,8 +89,8 @@ public class ExecutableLaunchConfiguration(string type)
     /// <remarks>
     /// Defaults to <see cref="ExecutableLaunchMode.Debug"/> when a debugger is attached to the app host
     /// and <see cref="ExecutableLaunchMode.NoDebug"/> otherwise. The mode requested by the IDE for the
-    /// current debug session is passed to the producer callback of
-    /// <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string)"/>.
+    /// current debug session is passed directly to mode-based producers and is available to context-based
+    /// producers through <see cref="LaunchConfigurationCallbackContext.Mode"/>.
     /// </remarks>
     [JsonPropertyName("mode")]
     public string Mode { get; set; } = System.Diagnostics.Debugger.IsAttached ? ExecutableLaunchMode.Debug : ExecutableLaunchMode.NoDebug;

src/Aspire.Hosting/ApplicationModel/LaunchConfigurationCallbackContext.cs

@@ -0,0 +1,58 @@
+// 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.ApplicationModel;
+
+/// <summary>
+/// Provides the runtime data used to create a launch configuration for a resource.
+/// </summary>
+/// <remarks>
+/// Aspire creates this context after resolving the execution configuration for a specific executable
+/// creation. Environment variable values may contain secrets; only copy values into the launch
+/// configuration when the IDE requires them.
+/// </remarks>
+[Experimental("ASPIREEXTENSION001", UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
+public sealed class LaunchConfigurationCallbackContext
+{
+    internal LaunchConfigurationCallbackContext(
+        string mode,
+        IResource resource,
+        IReadOnlyDictionary<string, string> environmentVariables,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(mode);
+        ArgumentNullException.ThrowIfNull(resource);
+        ArgumentNullException.ThrowIfNull(environmentVariables);
+
+        Mode = mode;
+        Resource = resource;
+        EnvironmentVariables = environmentVariables;
+        CancellationToken = cancellationToken;
+    }
+
+    /// <summary>
+    /// Gets the requested launch mode, one of the values on <see cref="ExecutableLaunchMode"/>.
+    /// </summary>
+    public string Mode { get; }
+
+    /// <summary>
+    /// Gets the resource being launched.
+    /// </summary>
+    public IResource Resource { get; }
+
+    /// <summary>
+    /// Gets the resolved environment variables used for this executable creation.
+    /// </summary>
+    /// <remarks>
+    /// Values can contain secrets. Aspire serializes only the launch configuration returned by the
+    /// producer; integrations should copy only values required by the IDE.
+    /// </remarks>
+    public IReadOnlyDictionary<string, string> EnvironmentVariables { get; }
+
+    /// <summary>
+    /// Gets the cancellation token for this executable creation.
+    /// </summary>
+    public CancellationToken CancellationToken { get; }
+}

src/Aspire.Hosting/Dcp/DcpExecutor.cs

@@ -178,7 +178,7 @@ public async Task RunApplicationAsync(CancellationToken ct = default)
                 {
                     containers = _containerCreator.PrepareObjects().ToArray();
                     _containerCreator.PrepareContainerExecutables();
-                    executables = (await _executableCreator.PrepareObjectsAsync(ct).ConfigureAwait(false)).ToArray();
+                    executables = _executableCreator.PrepareObjects(ct).ToArray();
 
                     prepareResourcesActivity.SetDcpPreparedResourceCounts(containers.Length, executables.Length);
                 }