Write Vite HTTPS config wrapper to node_modules/.aspire instead of node_modules/.bin

The generated aspire.vite.config wrapper was written to
node_modules/.bin/ which doesn't exist when package managers
hoist dependencies (e.g. yarn workspaces monorepos).

Walk up from the app directory to find the nearest node_modules
and write the wrapper to a .aspire subdirectory inside it. This
ensures Node.js module resolution can find bare imports like
'vite' while also handling hoisted dependency trees. The import
for the user's original config uses an absolute path so it
resolves correctly regardless of where the wrapper lives.

The config wrapper generation is moved to the
SubscribeHttpsEndpointsUpdate callback (which runs before the
cert config callback) so the endpoint scheme is only changed to
HTTPS when the wrapper was successfully created. If no
node_modules directory is found, a warning is logged and HTTPS
config is skipped gracefully.

Fixes #15853

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

Author: danegsta

src/Aspire.Hosting.JavaScript/JavaScriptHostingExtensions.cs

@@ -35,19 +35,19 @@ public static class JavaScriptHostingExtensions
     // See https://github.com/vitejs/vite/blob/main/packages/vite/src/node/constants.ts#L97
     private static readonly string[] s_defaultConfigFiles = ["vite.config.js", "vite.config.mjs", "vite.config.ts", "vite.config.cjs", "vite.config.mts", "vite.config.cts"];
 
-    // The token to replace with the relative path to the user's Vite config file
-    private const string AspireViteRelativeConfigToken = "%%ASPIRE_VITE_RELATIVE_CONFIG_PATH%%";
+    // The token to replace with the path to the user's Vite config file
+    private const string AspireViteConfigPathToken = "%%ASPIRE_VITE_CONFIG_PATH%%";
 
     // The token to replace with the absolute path to the original Vite config file
     private const string AspireViteAbsoluteConfigToken = "%%ASPIRE_VITE_ABSOLUTE_CONFIG_PATH%%";
 
     // A template Vite config that loads an existing config provides a default https configuration if one isn't present
     // Uses environment variables to configure a TLS certificate in PFX format and its password if specified
-    // The value of %%ASPIRE_VITE_RELATIVE_CONFIG_PATH%% is replaced with the path to the user's actual Vite config file at runtime
+    // The value of %%ASPIRE_VITE_CONFIG_PATH%% is replaced with the absolute path to the user's actual Vite config file at runtime
     // Vite only supports module style config files, so we don't have to handle commonjs style imports or exports here
     private const string AspireViteConfig = """
     import { defineConfig } from 'vite'
-    import config from '%%ASPIRE_VITE_RELATIVE_CONFIG_PATH%%'
+    import config from '%%ASPIRE_VITE_CONFIG_PATH%%'
 
     console.log('Applying Aspire specific Vite configuration for HTTPS support.')
     console.log('Found original Vite configuration at "%%ASPIRE_VITE_ABSOLUTE_CONFIG_PATH%%"')
@@ -949,25 +949,17 @@ public static IResourceBuilder<ViteAppResource> AddViteApp(this IDistributedAppl
             .WithoutHttpsCertificate()
             .WithHttpsCertificateConfiguration(async ctx =>
             {
-                string? configTarget = resource.ViteConfigPath;
+                // The Aspire HTTPS config wrapper is generated in SubscribeHttpsEndpointsUpdate below
+                // (which runs first). Here we just apply the --config argument and TLS env vars if it succeeded.
+                if (resource.AspireHttpsConfigPath is null)
+                {
+                    return;
+                }
 
-                // First we need to determine if there's an existing --config argument specified
+                // First we need to determine if there's an existing --config argument specified and remove it
                 var cfgIndex = ctx.Arguments.IndexOf("--config");
                 if (cfgIndex >= 0 && cfgIndex + 1 < ctx.Arguments.Count)
                 {
-                    configTarget = ctx.Arguments[cfgIndex + 1] switch
-                    {
-                        string s when !string.IsNullOrEmpty(s) && !s.StartsWith("--") => s,
-                        ReferenceExpression re => await re.GetValueAsync(ctx.CancellationToken).ConfigureAwait(false),
-                        _ => null,
-                    };
-
-                    if (string.IsNullOrEmpty(configTarget))
-                    {
-                        // Couldn't determine the config target, so don't modify anything
-                        return;
-                    }
-
                     // Remove the original --config argument and its value
                     ctx.Arguments.RemoveAt(cfgIndex);
                     ctx.Arguments.RemoveAt(cfgIndex);
@@ -978,9 +970,28 @@ public static IResourceBuilder<ViteAppResource> AddViteApp(this IDistributedAppl
                     return;
                 }
 
+                ctx.Arguments.Add("--config");
+                ctx.Arguments.Add(resource.AspireHttpsConfigPath);
+
+                ctx.EnvironmentVariables["TLS_CONFIG_PFX"] = ctx.PfxPath;
+                if (ctx.Password is not null)
+                {
+                    ctx.EnvironmentVariables["TLS_CONFIG_PASSWORD"] = ctx.Password;
+                }
+            });
+
+        if (builder.ExecutionContext.IsRunMode)
+        {
+            // Vite only supports a single endpoint, so we have to modify the existing endpoint to use HTTPS instead of
+            // adding a new one. This callback runs before the certificate config callback, so we generate the Aspire
+            // HTTPS config wrapper here and store the path on the resource for the cert callback to use.
+            resourceBuilder.SubscribeHttpsEndpointsUpdate(ctx =>
+            {
+                string? configTarget = resource.ViteConfigPath;
+
+                // If the user specified a config via WithViteConfig, use it; otherwise auto-detect
                 if (string.IsNullOrEmpty(configTarget))
                 {
-                    // The user didn't specify a specific vite config file, so we need to look for one of the default config files
                     foreach (var configFile in s_defaultConfigFiles)
                     {
                         var candidatePath = Path.GetFullPath(Path.Join(appDirectory, configFile));
@@ -992,57 +1003,49 @@ public static IResourceBuilder<ViteAppResource> AddViteApp(this IDistributedAppl
                     }
                 }
 
-                if (configTarget is not null)
+                if (configTarget is null)
                 {
-                    try
-                    {
-                        // Determine the absolute path to the original config file
-                        var absoluteConfigPath = Path.GetFullPath(configTarget, appDirectory);
-                        // Determine the relative path from the Aspire vite config to the original config file
-                        var relativeConfigPath = Path.GetRelativePath(Path.Join(appDirectory, "node_modules", ".bin"), absoluteConfigPath);
-
-                        // If we are expecting to run the vite app with HTTPS termination, generate an Aspire specific Vite config file that can mutate the user's original config
-                        var aspireConfig = AspireViteConfig
-                            .Replace(AspireViteRelativeConfigToken, relativeConfigPath.Replace("\\", "/"), StringComparison.Ordinal)
-                            .Replace(AspireViteAbsoluteConfigToken, absoluteConfigPath.Replace("\\", "\\\\"), StringComparison.Ordinal);
-                        var aspireConfigPath = Path.Join(appDirectory, "node_modules", ".bin", $"aspire.{Path.GetFileName(configTarget)}");
-                        File.WriteAllText(aspireConfigPath, aspireConfig);
-
-                        // Override the path to the Vite config file to use the Aspire generated one. If we made it here, we
-                        // know there isn't an existing --config argument present.
-                        ctx.Arguments.Add("--config");
-                        ctx.Arguments.Add(aspireConfigPath);
-
-                        ctx.EnvironmentVariables["TLS_CONFIG_PFX"] = ctx.PfxPath;
-                        if (ctx.Password is not null)
-                        {
-                            ctx.EnvironmentVariables["TLS_CONFIG_PASSWORD"] = ctx.Password;
-                        }
-                    }
-                    catch (Exception ex)
+                    return;
+                }
+
+                try
+                {
+                    var absoluteConfigPath = Path.GetFullPath(configTarget, appDirectory);
+
+                    // Find the nearest node_modules directory by walking up from the app directory.
+                    // This handles package managers that hoist dependencies (e.g. yarn workspaces)
+                    // where node_modules lives at the repo root rather than in the app directory.
+                    // Writing inside node_modules ensures Node.js module resolution can find
+                    // bare imports like 'vite' in the generated wrapper config.
+                    var nodeModulesDir = FindNearestNodeModules(appDirectory);
+                    if (nodeModulesDir is null)
                     {
-                        var resourceLoggerService = ctx.ExecutionContext.ServiceProvider.GetRequiredService<ResourceLoggerService>();
+                        var resourceLoggerService = ctx.Services.GetRequiredService<ResourceLoggerService>();
                         var resourceLogger = resourceLoggerService.GetLogger(resource);
+                        resourceLogger.LogWarning("Could not find a node_modules directory in or above '{AppDirectory}' for resource '{ResourceName}'. Automatic HTTPS configuration won't be available. Ensure packages are installed before starting the app.", appDirectory, resource.Name);
+                        return;
+                    }
 
-                        resourceLogger.LogWarning(ex, "Failed to generate Aspire Vite HTTPS config wrapper for resource '{ResourceName}'. Falling back to existing Vite config without Aspire modifications. Automatic HTTPS configuration won't be available", resource.Name);
+                    var aspireConfigDir = Path.Join(nodeModulesDir, ".aspire");
+                    Directory.CreateDirectory(aspireConfigDir);
 
-                        if (!string.IsNullOrEmpty(configTarget))
-                        {
-                            // Fallback to using the existing config target
-                            ctx.Arguments.Add("--config");
-                            ctx.Arguments.Add(configTarget);
-                        }
-                    }
-                }
-            });
+                    var importPath = absoluteConfigPath.Replace("\\", "/");
 
-        if (builder.ExecutionContext.IsRunMode)
-        {
-            // Vite only supports a single endpoint, so we have to modify the existing endpoint to use HTTPS instead of
-            // adding a new one.
-            resourceBuilder.SubscribeHttpsEndpointsUpdate(ctx =>
-            {
-                resourceBuilder.WithEndpoint("http", ep => ep.UriScheme = "https");
+                    var aspireConfig = AspireViteConfig
+                        .Replace(AspireViteConfigPathToken, importPath, StringComparison.Ordinal)
+                        .Replace(AspireViteAbsoluteConfigToken, absoluteConfigPath.Replace("\\", "\\\\"), StringComparison.Ordinal);
+                    var aspireConfigPath = Path.Join(aspireConfigDir, $"aspire.{Path.GetFileName(configTarget)}");
+                    File.WriteAllText(aspireConfigPath, aspireConfig);
+
+                    resource.AspireHttpsConfigPath = aspireConfigPath;
+                    resourceBuilder.WithEndpoint("http", ep => ep.UriScheme = "https");
+                }
+                catch (Exception ex)
+                {
+                    var resourceLoggerService = ctx.Services.GetRequiredService<ResourceLoggerService>();
+                    var resourceLogger = resourceLoggerService.GetLogger(resource);
+                    resourceLogger.LogWarning(ex, "Failed to generate Aspire Vite HTTPS config wrapper for resource '{ResourceName}'. Falling back to existing Vite config without Aspire modifications. Automatic HTTPS configuration won't be available", resource.Name);
+                }
             });
         }
 
@@ -1795,6 +1798,31 @@ private static void ValidateApiPath(string apiPath)
         }
     }
 
+    /// <summary>
+    /// Walks up from <paramref name="startDirectory"/> to find the nearest <c>node_modules</c> directory.
+    /// </summary>
+    private static string? FindNearestNodeModules(string startDirectory)
+    {
+        var current = Path.GetFullPath(startDirectory);
+        while (current is not null)
+        {
+            var candidate = Path.Join(current, "node_modules");
+            if (Directory.Exists(candidate))
+            {
+                return candidate;
+            }
+
+            var parent = Path.GetDirectoryName(current);
+            if (parent == current)
+            {
+                break;
+            }
+            current = parent;
+        }
+
+        return null;
+    }
+
     private static string NormalizeRelativePath(string path)
     {
         var normalizedPath = path.Replace('\\', '/');

src/Aspire.Hosting.JavaScript/ViteAppResource.cs

@@ -17,4 +17,9 @@ public class ViteAppResource(string name, string command, string workingDirector
     /// Gets or sets the path to the Vite configuration file.
     /// </summary>
     internal string? ViteConfigPath { get; set; }
+
+    /// <summary>
+    /// Gets or sets the path to the generated Aspire HTTPS config wrapper, if successfully created.
+    /// </summary>
+    internal string? AspireHttpsConfigPath { get; set; }
 }