Fix aspire run graceful shtudown behavior and unify with aspire start/aspire stop.

src/Aspire.Cli/Commands/AppHostLauncher.cs

@@ -33,7 +33,7 @@ internal sealed class AppHostLauncher(
     AspireCliTelemetry telemetry,
     ProfilingTelemetry profilingTelemetry,
     FileLoggerProvider fileLoggerProvider,
-    ProcessShutdownService processShutdownService,
+    ProcessTreeGracefulShutdownService processShutdownService,
     IDetachedProcessLauncher detachedProcessLauncher,
     ILogger<AppHostLauncher> logger,
     TimeProvider timeProvider)

src/Aspire.Cli/Commands/BaseCommand.cs

@@ -26,6 +26,15 @@ internal abstract class BaseCommand : Command
     /// </summary>
     internal virtual HelpGroup HelpGroup => HelpGroup.None;
 
+    /// <summary>
+    /// The graceful-shutdown budget this command grants its child processes before shutdown ladders
+    /// escalate to forceful termination. <see cref="BaseCommand"/> reads this and configures the
+    /// shared <see cref="ConsoleCancellationManager"/> centrally before invoking <see cref="ExecuteAsync"/>.
+    /// The default of zero preserves force-kill-on-cancel behavior for every command that does not opt in;
+    /// <c>aspire run</c> overrides it to give the AppHost a real cooperative-shutdown window.
+    /// </summary>
+    protected virtual TimeSpan GracefulShutdownBudget => TimeSpan.Zero;
+
     private readonly CliExecutionContext _executionContext;
 
     protected CliExecutionContext ExecutionContext => _executionContext;
@@ -60,6 +69,12 @@ protected BaseCommand(string name, string description, CommonCommandServices ser
             var stoppingMessageShown = false;
             try
             {
+                // Configure the shared shutdown manager with this command's graceful-shutdown budget
+                // before the handler starts spawning child processes, so every per-child shutdown
+                // ladder observes the correct window from the first user signal. Commands that don't
+                // override GracefulShutdownBudget get the zero default (force-kill on cancel).
+                services.CancellationManager.ConfigureForCommand(GracefulShutdownBudget);
+
                 var handlerTask = ExecuteAsync(parseResult, cancellationToken);
                 services.CancellationManager.SetStartedHandler(handlerTask);
 

src/Aspire.Cli/Commands/DashboardRunCommand.cs

@@ -371,7 +371,7 @@ private async Task<CommandResult> ExecuteForegroundAsync(string managedPath, Lis
         IProcessExecution process;
         try
         {
-            process = _layoutProcessRunner.Start(managedPath, dashboardArgs, environmentVariables: environmentVariables, options: options);
+            process = await _layoutProcessRunner.StartAsync(managedPath, dashboardArgs, environmentVariables: environmentVariables, options: options).ConfigureAwait(false);
         }
         catch (Exception ex)
         {
@@ -380,7 +380,7 @@ private async Task<CommandResult> ExecuteForegroundAsync(string managedPath, Lis
             return CommandResult.Failure(CliExitCodes.DashboardFailure);
         }
 
-        using var _ = process;
+        await using var _ = process;
 
         // Wait for the dashboard to become ready, the process to exit, or a timeout.
         var processExitTask = process.WaitForExitAsync(cancellationToken);

src/Aspire.Cli/Commands/RunCommand.cs

@@ -77,13 +77,25 @@ internal sealed class RunCommand : BaseCommand
 
     private static readonly TimeSpan s_appHostStartupCancellationTimeout = TimeSpan.FromSeconds(5);
 
+    // Graceful shutdown budget for `aspire run`. DCP gets a cooperative window to drain
+    // resources before the central drain budget arms and ladders escalate to forceful kill.
+    // 5s is comfortably enough for a default starter template (apphost + 2 services +
+    // dashboard) once CTRL+C actually reaches the AppHost — measured graceful exits run
+    // ~700ms end-to-end. Earlier observations of ~6s drains were an artifact of the
+    // inherited "ignore CTRL+C" attribute (cleared in Program.cs Main on Windows) which
+    // caused DCP to fall back to its internal 6s SIGKILL deadline because the kernel was
+    // silently dropping the CTRL_C_EVENT.
+    internal static readonly TimeSpan s_gracefulShutdownBudget = TimeSpan.FromSeconds(5);
+
     // Guest AppHosts can bring up the temporary server/backchannel and then fail immediately
     // afterward when the guest startup process hits a syntax, pre-execute, or model validation
     // error. Keep guest AppHost startup waits alive briefly so those failures are reported instead of hidden.
     private static readonly TimeSpan s_startupFailureObservationWindow = TimeSpan.FromSeconds(2);
 
     protected override bool UpdateNotificationsEnabled => !_isDetachMode;
 
+    protected override TimeSpan GracefulShutdownBudget => s_gracefulShutdownBudget;
+
     private static readonly Option<bool> s_detachOption = new("--detach")
     {
         Description = RunCommandStrings.DetachArgumentDescription
@@ -504,9 +516,10 @@ await InteractionService.DisplayLiveAsync(BuildLiveRenderable(), async updateTar
             {
                 runActivity?.SetTag(TelemetryConstants.Tags.ErrorType, "canceled");
 
-                // The user cancelled (e.g. Ctrl+C); the linked CTS we passed to project.RunAsync
-                // propagated the cancellation and the OCE bubbled out with the linked token.
-                // Treat as successful exit since the user intentionally stopped the AppHost.
+                // User Ctrl+C is the normal exit path for `aspire run`; surface as success.
+                // Internal failures `return X` directly from GuestAppHostProject.RunAsync rather
+                // than flowing through this catch, so we don't need to distinguish failure codes
+                // here.
                 return CommandResult.Cancelled(CliExitCodes.Success);
             }
             finally
@@ -529,8 +542,9 @@ await InteractionService.DisplayLiveAsync(BuildLiveRenderable(), async updateTar
         {
             runActivity?.SetTag(TelemetryConstants.Tags.ErrorType, "canceled");
 
-            // Command is designed to be cancellable by the user (e.g. Ctrl+C) at any time.
-            // Treat cancellation as a successful exit since the user intentionally stopped the AppHost.
+            // User Ctrl+C is the normal exit path for `aspire run`; surface as success.
+            // Internal failures `return X` directly from GuestAppHostProject.RunAsync rather
+            // than flowing through this catch.
             return CommandResult.Cancelled(CliExitCodes.Success);
         }
         catch (ProjectLocatorException ex)

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

@@ -33,7 +33,7 @@ namespace Aspire.Cli.Commands.Sdk;
 internal sealed class SdkDumpCommand : BaseCommand
 {
     private readonly IAppHostServerProjectFactory _appHostServerProjectFactory;
-    private readonly IAppHostServerSessionFactory _appHostServerSessionFactory;
+    private readonly IAppHostServerSessionFactory _serverSessionFactory;
     private readonly ILogger<SdkDumpCommand> _logger;
 
     private static readonly Argument<string[]> s_integrationArgument = new("integrations")
@@ -56,13 +56,13 @@ internal sealed class SdkDumpCommand : BaseCommand
 
     public SdkDumpCommand(
         IAppHostServerProjectFactory appHostServerProjectFactory,
-        IAppHostServerSessionFactory appHostServerSessionFactory,
+        IAppHostServerSessionFactory serverSessionFactory,
         ILogger<SdkDumpCommand> logger,
         CommonCommandServices services)
         : base("dump", "Dump ATS capabilities from Aspire integration libraries.", services)
     {
         _appHostServerProjectFactory = appHostServerProjectFactory;
-        _appHostServerSessionFactory = appHostServerSessionFactory;
+        _serverSessionFactory = serverSessionFactory;
         _logger = logger;
 
         Arguments.Add(s_integrationArgument);
@@ -193,10 +193,11 @@ private async Task<int> DumpCapabilitiesAsync(
                 return CliExitCodes.FailedToBuildArtifacts;
             }
 
-            await using var serverSession = _appHostServerSessionFactory.Start(
-                appHostServerProject,
-                environmentVariables: null,
-                debug: false);
+            await using var serverSession = _serverSessionFactory.Create(appHostServerProject, environmentVariables: null, debug: false, gracefulShutdownSignaler: null, shutdownService: null, isolateConsole: false, cancellationToken);
+            // Short-lived RPC session: StartAsync() spawns the server. We never observe the
+            // exit-code task (WaitForExitAsync) because disposal flows the exit code through the
+            // activity scope and the only failure mode we care about surfaces via the RPC call below.
+            await serverSession.StartAsync();
 
             // Connect and get capabilities
             var rpcClient = await serverSession.GetRpcClientAsync(cancellationToken);
@@ -291,10 +292,11 @@ private async Task<int> DumpCapabilitiesToDirectoryAsync(
                 return CliExitCodes.FailedToBuildArtifacts;
             }
 
-            await using var serverSession = _appHostServerSessionFactory.Start(
-                appHostServerProject,
-                environmentVariables: null,
-                debug: false);
+            await using var serverSession = _serverSessionFactory.Create(appHostServerProject, environmentVariables: null, debug: false, gracefulShutdownSignaler: null, shutdownService: null, isolateConsole: false, cancellationToken);
+            // Short-lived RPC session: StartAsync() spawns the server. We never observe the
+            // exit-code task (WaitForExitAsync) because disposal flows the exit code through the
+            // activity scope and the only failure mode we care about surfaces via the RPC call below.
+            await serverSession.StartAsync();
 
             var rpcClient = await serverSession.GetRpcClientAsync(cancellationToken);
             outputDirectory.Create();

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

@@ -20,7 +20,7 @@ internal sealed class SdkGenerateCommand : BaseCommand
 {
     private readonly ILanguageDiscovery _languageDiscovery;
     private readonly IAppHostServerProjectFactory _appHostServerProjectFactory;
-    private readonly IAppHostServerSessionFactory _appHostServerSessionFactory;
+    private readonly IAppHostServerSessionFactory _serverSessionFactory;
     private readonly ILogger<SdkGenerateCommand> _logger;
 
     private static readonly Argument<FileInfo> s_integrationArgument = new("integration")
@@ -41,14 +41,14 @@ internal sealed class SdkGenerateCommand : BaseCommand
     public SdkGenerateCommand(
         ILanguageDiscovery languageDiscovery,
         IAppHostServerProjectFactory appHostServerProjectFactory,
-        IAppHostServerSessionFactory appHostServerSessionFactory,
+        IAppHostServerSessionFactory serverSessionFactory,
         ILogger<SdkGenerateCommand> logger,
         CommonCommandServices services)
         : base("generate", "Generate typed SDKs from an Aspire integration library for use in other languages.", services)
     {
         _languageDiscovery = languageDiscovery;
         _appHostServerProjectFactory = appHostServerProjectFactory;
-        _appHostServerSessionFactory = appHostServerSessionFactory;
+        _serverSessionFactory = serverSessionFactory;
         _logger = logger;
 
         Arguments.Add(s_integrationArgument);
@@ -154,10 +154,11 @@ private async Task<int> GenerateSdkAsync(
                 return CliExitCodes.FailedToBuildArtifacts;
             }
 
-            await using var serverSession = _appHostServerSessionFactory.Start(
-                appHostServerProject,
-                environmentVariables: null,
-                debug: false);
+            await using var serverSession = _serverSessionFactory.Create(appHostServerProject, environmentVariables: null, debug: false, gracefulShutdownSignaler: null, shutdownService: null, isolateConsole: false, cancellationToken);
+            // Short-lived RPC session: StartAsync() spawns the server. We never observe the
+            // exit-code task (WaitForExitAsync) because disposal flows the exit code through the
+            // activity scope and the only failure mode we care about surfaces via the RPC call below.
+            await serverSession.StartAsync();
 
             // Connect and generate code
             var rpcClient = await serverSession.GetRpcClientAsync(cancellationToken);

src/Aspire.Cli/Commands/StopCommand.cs

@@ -22,7 +22,7 @@ internal sealed class StopCommand : BaseCommand
     private readonly AppHostConnectionResolver _connectionResolver;
     private readonly ILogger<StopCommand> _logger;
     private readonly ICliHostEnvironment _hostEnvironment;
-    private readonly ProcessShutdownService _processShutdownService;
+    private readonly ProcessTreeGracefulShutdownService _processShutdownService;
     private readonly ProfilingTelemetry _profilingTelemetry;
 
     private static readonly OptionWithLegacy<FileInfo?> s_appHostOption = new("--apphost", "--project", StopCommandStrings.ProjectArgumentDescription);
@@ -35,7 +35,7 @@ internal sealed class StopCommand : BaseCommand
     public StopCommand(
         AppHostConnectionResolver connectionResolver,
         ICliHostEnvironment hostEnvironment,
-        ProcessShutdownService processShutdownService,
+        ProcessTreeGracefulShutdownService processShutdownService,
         ILogger<StopCommand> logger,
         ProfilingTelemetry profilingTelemetry,
         CommonCommandServices services)