Improve detach mode: fix pipe handle inheritance and unify log naming

src/Aspire.Cli/Commands/CacheCommand.cs

@@ -45,7 +45,7 @@ protected override Task<int> ExecuteAsync(ParseResult parseResult, CancellationT
             {
                 var cacheDirectory = ExecutionContext.CacheDirectory;
                 var filesDeleted = 0;
-                
+
                 // Delete cache files and subdirectories
                 if (cacheDirectory.Exists)
                 {
@@ -110,14 +110,13 @@ protected override Task<int> ExecuteAsync(ParseResult parseResult, CancellationT
 
                 // Also clear the logs directory (skip current process's log file)
                 var logsDirectory = ExecutionContext.LogsDirectory;
-                // Log files are named cli-{timestamp}-{pid}.log, so we need to check the suffix
-                var currentLogFileSuffix = $"-{Environment.ProcessId}.log";
+                var currentLogFilePath = ExecutionContext.LogFilePath;
                 if (logsDirectory.Exists)
                 {
                     foreach (var file in logsDirectory.GetFiles("*", SearchOption.AllDirectories))
                     {
                         // Skip the current process's log file to avoid deleting it while in use
-                        if (file.Name.EndsWith(currentLogFileSuffix, StringComparison.OrdinalIgnoreCase))
+                        if (file.FullName.Equals(currentLogFilePath, StringComparison.OrdinalIgnoreCase))
                         {
                             continue;
                         }
@@ -167,4 +166,4 @@ protected override Task<int> ExecuteAsync(ParseResult parseResult, CancellationT
             }
         }
     }
-}
+}

src/Aspire.Cli/Commands/RunCommand.cs

@@ -82,6 +82,11 @@ internal sealed class RunCommand : BaseCommand
     {
         Description = RunCommandStrings.IsolatedArgumentDescription
     };
+    private static readonly Option<string?> s_logFileOption = new("--log-file")
+    {
+        Description = "Path to write the log file (used internally by --detach).",
+        Hidden = true
+    };
     private readonly Option<bool>? _startDebugSessionOption;
 
     public RunCommand(
@@ -121,6 +126,7 @@ public RunCommand(
         Options.Add(s_detachOption);
         Options.Add(s_formatOption);
         Options.Add(s_isolatedOption);
+        Options.Add(s_logFileOption);
 
         if (ExtensionHelper.IsExtensionHost(InteractionService, out _, out _))
         {
@@ -278,9 +284,9 @@ protected override async Task<int> ExecuteAsync(ParseResult parseResult, Cancell
 
             // Handle remote environments (Codespaces, Remote Containers, SSH)
             var isCodespaces = dashboardUrls.CodespacesUrlWithLoginToken is not null;
-            var isRemoteContainers = _configuration.GetValue<bool>("REMOTE_CONTAINERS", false);
-            var isSshRemote = _configuration.GetValue<string?>("VSCODE_IPC_HOOK_CLI") is not null
-                              && _configuration.GetValue<string?>("SSH_CONNECTION") is not null;
+            var isRemoteContainers = string.Equals(_configuration["REMOTE_CONTAINERS"], "true", StringComparison.OrdinalIgnoreCase);
+            var isSshRemote = _configuration["VSCODE_IPC_HOOK_CLI"] is not null
+                              && _configuration["SSH_CONNECTION"] is not null;
 
             AppendCtrlCMessage(longestLocalizedLengthWithColon);
 
@@ -476,7 +482,7 @@ internal static int RenderAppHostSummary(
                     new Align(new Markup($"[bold green]{dashboardLabel}[/]:"), HorizontalAlignment.Right),
                     new Markup("[dim]N/A[/]"));
             }
-            grid.AddRow(Text.Empty, Text.Empty);   
+            grid.AddRow(Text.Empty, Text.Empty);
         }
 
         // Logs row
@@ -639,18 +645,23 @@ private async Task<int> ExecuteDetachedAsync(ParseResult parseResult, FileInfo?
             _logger.LogDebug("Found {Count} running instance(s) for this AppHost, stopping them first", existingSockets.Length);
             var manager = new RunningInstanceManager(_logger, _interactionService, _timeProvider);
             // Stop all running instances in parallel - don't block on failures
-            var stopTasks = existingSockets.Select(socket => 
+            var stopTasks = existingSockets.Select(socket =>
                 manager.StopRunningInstanceAsync(socket, cancellationToken));
             await Task.WhenAll(stopTasks).ConfigureAwait(false);
         }
 
         // Build the arguments for the child CLI process
+        // Tell the child where to write its log so we can find it on failure.
+        var childLogFile = GenerateChildLogFilePath();
+
         var args = new List<string>
         {
             "run",
             "--non-interactive",
             "--project",
-            effectiveAppHostFile.FullName
+            effectiveAppHostFile.FullName,
+            "--log-file",
+            childLogFile
         };
 
         // Pass through global options that should be forwarded to child CLI
@@ -687,14 +698,17 @@ private async Task<int> ExecuteDetachedAsync(ParseResult parseResult, FileInfo?
             dotnetPath, isDotnetHost, string.Join(" ", args));
         _logger.LogDebug("Working directory: {WorkingDirectory}", ExecutionContext.WorkingDirectory.FullName);
 
-        // Redirect stdout/stderr to suppress child output - it writes to log file anyway
+        // Don't redirect stdout/stderr - child writes to log file anyway.
+        // Redirecting creates pipe handles that get inherited by the AppHost grandchild,
+        // which prevents callers using synchronous process APIs (e.g. execSync) from
+        // detecting that the CLI has exited, since the pipe stays open until the AppHost dies.
         var startInfo = new ProcessStartInfo
         {
             FileName = dotnetPath,
             UseShellExecute = false,
             CreateNoWindow = true,
-            RedirectStandardOutput = true,
-            RedirectStandardError = true,
+            RedirectStandardOutput = false,
+            RedirectStandardError = false,
             RedirectStandardInput = false,
             WorkingDirectory = ExecutionContext.WorkingDirectory.FullName
         };
@@ -727,24 +741,6 @@ private async Task<int> ExecuteDetachedAsync(ParseResult parseResult, FileInfo?
                     return null;
                 }
 
-                // Start async reading of stdout/stderr to prevent buffer blocking
-                // Log output for debugging purposes
-                childProcess.OutputDataReceived += (_, e) =>
-                {
-                    if (e.Data is not null)
-                    {
-                        _logger.LogDebug("Child stdout: {Line}", e.Data);
-                    }
-                };
-                childProcess.ErrorDataReceived += (_, e) =>
-                {
-                    if (e.Data is not null)
-                    {
-                        _logger.LogDebug("Child stderr: {Line}", e.Data);
-                    }
-                };
-                childProcess.BeginOutputReadLine();
-                childProcess.BeginErrorReadLine();
             }
             catch (Exception ex)
             {
@@ -823,10 +819,13 @@ private async Task<int> ExecuteDetachedAsync(ParseResult parseResult, FileInfo?
 
             if (childExitedEarly)
             {
-                _interactionService.DisplayError(string.Format(
-                    CultureInfo.CurrentCulture,
-                    RunCommandStrings.AppHostExitedWithCode,
-                    childExitCode));
+                // Show a friendly message based on well-known exit codes from the child
+                var errorMessage = childExitCode switch
+                {
+                    ExitCodeConstants.FailedToBuildArtifacts => RunCommandStrings.AppHostFailedToBuild,
+                    _ => string.Format(CultureInfo.CurrentCulture, RunCommandStrings.AppHostExitedWithCode, childExitCode)
+                };
+                _interactionService.DisplayError(errorMessage);
             }
             else
             {
@@ -846,11 +845,11 @@ private async Task<int> ExecuteDetachedAsync(ParseResult parseResult, FileInfo?
                 }
             }
 
-            // Always show log file path for troubleshooting
+            // Point to the child's log file — it contains the actual build/runtime errors
             _interactionService.DisplayMessage("magnifying_glass_tilted_right", string.Format(
                 CultureInfo.CurrentCulture,
                 RunCommandStrings.CheckLogsForDetails,
-                _fileLoggerProvider.LogFilePath.EscapeMarkup()));
+                childLogFile.EscapeMarkup()));
 
             return ExitCodeConstants.FailedToDotnetRunAppHost;
         }
@@ -893,4 +892,12 @@ private async Task<int> ExecuteDetachedAsync(ParseResult parseResult, FileInfo?
 
         return ExitCodeConstants.Success;
     }
+
+    private string GenerateChildLogFilePath()
+    {
+        return Diagnostics.FileLoggerProvider.GenerateLogFilePath(
+            ExecutionContext.LogsDirectory.FullName,
+            _timeProvider,
+            suffix: "detach-child");
+    }
 }

src/Aspire.Cli/Diagnostics/FileLoggerProvider.cs

@@ -29,6 +29,22 @@ internal sealed class FileLoggerProvider : ILoggerProvider
     /// </summary>
     public string LogFilePath => _logFilePath;
 
+    /// <summary>
+    /// Generates a unique, chronologically-sortable log file name.
+    /// </summary>
+    /// <param name="logsDirectory">The directory where log files will be written.</param>
+    /// <param name="timeProvider">The time provider for timestamp generation.</param>
+    /// <param name="suffix">An optional suffix appended before the extension (e.g. "detach-child").</param>
+    internal static string GenerateLogFilePath(string logsDirectory, TimeProvider timeProvider, string? suffix = null)
+    {
+        var timestamp = timeProvider.GetUtcNow().ToString("yyyyMMdd'T'HHmmss", CultureInfo.InvariantCulture);
+        var id = Guid.NewGuid().ToString("N")[..8];
+        var name = suffix is null
+            ? $"cli_{timestamp}_{id}.log"
+            : $"cli_{timestamp}_{id}_{suffix}.log";
+        return Path.Combine(logsDirectory, name);
+    }
+
     /// <summary>
     /// Creates a new FileLoggerProvider that writes to the specified directory.
     /// </summary>
@@ -37,10 +53,7 @@ internal sealed class FileLoggerProvider : ILoggerProvider
     /// <param name="errorConsole">Optional console for error messages. Defaults to stderr.</param>
     public FileLoggerProvider(string logsDirectory, TimeProvider timeProvider, IAnsiConsole? errorConsole = null)
     {
-        var pid = Environment.ProcessId;
-        var timestamp = timeProvider.GetUtcNow().ToString("yyyy-MM-dd-HH-mm-ss", CultureInfo.InvariantCulture);
-        // Timestamp first so files sort chronologically by name
-        _logFilePath = Path.Combine(logsDirectory, $"cli-{timestamp}-{pid}.log");
+        _logFilePath = GenerateLogFilePath(logsDirectory, timeProvider);
 
         try
         {

src/Aspire.Cli/Program.cs

@@ -91,6 +91,28 @@ private static (LogLevel? ConsoleLogLevel, bool DebugMode) ParseLoggingOptions(s
         return (logLevel, debugMode);
     }
 
+    /// <summary>
+    /// Parses --log-file from raw args before the host is built.
+    /// Used by --detach to tell the child CLI where to write its log.
+    /// </summary>
+    private static string? ParseLogFileOption(string[]? args)
+    {
+        if (args is null)
+        {
+            return null;
+        }
+
+        for (var i = 0; i < args.Length; i++)
+        {
+            if (args[i] == "--log-file" && i + 1 < args.Length)
+            {
+                return args[i + 1];
+            }
+        }
+
+        return null;
+    }
+
     private static string GetGlobalSettingsPath()
     {
         var usersAspirePath = GetUsersAspirePath();
@@ -158,7 +180,10 @@ internal static async Task<IHost> BuildApplicationAsync(string[] args, Dictionar
         // Always register FileLoggerProvider to capture logs to disk
         // This captures complete CLI session details for diagnostics
         var logsDirectory = Path.Combine(GetUsersAspirePath(), "logs");
-        var fileLoggerProvider = new FileLoggerProvider(logsDirectory, TimeProvider.System);
+        var logFilePath = ParseLogFileOption(args);
+        var fileLoggerProvider = logFilePath is not null
+            ? new FileLoggerProvider(logFilePath)
+            : new FileLoggerProvider(logsDirectory, TimeProvider.System);
         builder.Services.AddSingleton(fileLoggerProvider); // Register for direct access to LogFilePath
         builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider>(fileLoggerProvider));
 

src/Aspire.Cli/Resources/RunCommandStrings.resx

@@ -226,6 +226,9 @@
   <data name="AppHostExitedWithCode" xml:space="preserve">
     <value>AppHost process exited with code {0}.</value>
   </data>
+  <data name="AppHostFailedToBuild" xml:space="preserve">
+    <value>AppHost failed to build.</value>
+  </data>
   <data name="TimeoutWaitingForAppHost" xml:space="preserve">
     <value>Timeout waiting for AppHost to start.</value>
   </data>