Support AppHost startup timeout env var

src/Aspire.Cli/CliConfigNames.cs

@@ -7,4 +7,5 @@ namespace Aspire.Cli;
 internal static class CliConfigNames
 {
     public const string NoLogo = "ASPIRE_CLI_NOLOGO";
+    public const string AppHostStartupTimeout = "ASPIRE_CLI_START_TIMEOUT";
 }

src/Aspire.Cli/Commands/AppHostLauncher.cs

@@ -83,6 +83,7 @@ internal static void AddLaunchOptions(Command command)
     /// <param name="isolated">Whether to run in isolated mode.</param>
     /// <param name="isExtensionHost">Whether running inside VS Code extension.</param>
     /// <param name="waitForDebugger">Whether the AppHost is waiting for a debugger to attach.</param>
+    /// <param name="timeoutSeconds">The maximum number of seconds to wait for AppHost startup.</param>
     /// <param name="globalArgs">Global CLI args to forward to child process.</param>
     /// <param name="additionalArgs">Additional unmatched args to forward.</param>
     /// <param name="stopAfterLaunchDelay">Optional delay after launch before stopping the AppHost.</param>
@@ -94,6 +95,7 @@ public async Task<CommandResult> LaunchDetachedAsync(
         bool isolated,
         bool isExtensionHost,
         bool waitForDebugger,
+        int timeoutSeconds,
         IEnumerable<string> globalArgs,
         IEnumerable<string> additionalArgs,
         TimeSpan? stopAfterLaunchDelay,
@@ -165,7 +167,7 @@ public async Task<CommandResult> LaunchDetachedAsync(
         {
             launchResult = await interactionService.ShowDynamicStatusAsync(
                 RunCommandStrings.StartingAppHostInBackground,
-                updateStatus => LaunchAndWaitForBackchannelAsync(executablePath, childArgs, expectedHash, legacyHashes, updateStatus, cancellationToken));
+                updateStatus => LaunchAndWaitForBackchannelAsync(executablePath, childArgs, expectedHash, legacyHashes, TimeSpan.FromSeconds(timeoutSeconds), updateStatus, cancellationToken));
         }
         catch (OperationCanceledException)
         {
@@ -175,7 +177,7 @@ public async Task<CommandResult> LaunchDetachedAsync(
         // Handle failure cases
         if (launchResult.Backchannel is null || launchResult.ChildProcess is null)
         {
-            return HandleLaunchFailure(launchResult, childLogFile);
+            return HandleLaunchFailure(launchResult, childLogFile, timeoutSeconds);
         }
 
         // Display results
@@ -323,6 +325,7 @@ private async Task<LaunchResult> LaunchAndWaitForBackchannelAsync(
         List<string> childArgs,
         string expectedHash,
         IReadOnlyList<string> legacyHashes,
+        TimeSpan timeout,
         Action<string> updateStatus,
         CancellationToken cancellationToken)
     {
@@ -352,7 +355,6 @@ private async Task<LaunchResult> LaunchAndWaitForBackchannelAsync(
         logger.LogDebug("Child CLI process started with PID: {PID}", childProcess.Id);
 
         var startTime = timeProvider.GetUtcNow();
-        var timeout = TimeSpan.FromSeconds(120);
         using var waitForBackchannelActivity = profilingTelemetry.StartDetachedWaitForBackchannel(childProcess.Id, expectedHash, legacyHashes.Count > 0);
         var scanCount = 0;
         IAppHostAuxiliaryBackchannel? connection = null;
@@ -629,7 +631,7 @@ private static void ObserveFaults(Task task)
             TaskScheduler.Default);
     }
 
-    private CommandResult HandleLaunchFailure(LaunchResult result, string childLogFile)
+    private CommandResult HandleLaunchFailure(LaunchResult result, string childLogFile, int timeoutSeconds)
     {
         if (result.ChildProcess is null)
         {
@@ -649,7 +651,7 @@ private CommandResult HandleLaunchFailure(LaunchResult result, string childLogFi
         }
         else
         {
-            failureMessage = RunCommandStrings.TimeoutWaitingForAppHost;
+            failureMessage = string.Format(CultureInfo.CurrentCulture, RunCommandStrings.TimeoutWaitingForAppHost, timeoutSeconds, CliConfigNames.AppHostStartupTimeout);
         }
 
         interactionService.DisplayError(RunCommandStrings.FailedToStartAppHost);

src/Aspire.Cli/Commands/AppHostStartupTimeout.cs

@@ -0,0 +1,36 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Globalization;
+using Aspire.Cli.Interaction;
+using Aspire.Cli.Resources;
+using Microsoft.Extensions.Configuration;
+
+namespace Aspire.Cli.Commands;
+
+internal static class AppHostStartupTimeout
+{
+    public static bool TryGetTimeoutSeconds(IConfiguration configuration, IInteractionService interactionService, out int timeoutSeconds)
+    {
+        timeoutSeconds = WaitCommand.DefaultTimeoutSeconds;
+
+        var configuredTimeout = configuration[CliConfigNames.AppHostStartupTimeout];
+        if (string.IsNullOrWhiteSpace(configuredTimeout))
+        {
+            return true;
+        }
+
+        if (int.TryParse(configuredTimeout, NumberStyles.None, CultureInfo.InvariantCulture, out var parsedTimeout) &&
+            parsedTimeout > 0)
+        {
+            timeoutSeconds = parsedTimeout;
+            return true;
+        }
+
+        interactionService.DisplayError(string.Format(
+            CultureInfo.CurrentCulture,
+            RunCommandStrings.InvalidAppHostStartupTimeoutEnvironmentVariable,
+            CliConfigNames.AppHostStartupTimeout));
+        return false;
+    }
+}

src/Aspire.Cli/Commands/RunCommand.cs

@@ -72,9 +72,12 @@ internal sealed class RunCommand : BaseCommand
     private readonly FileLoggerProvider _fileLoggerProvider;
     private readonly ICliHostEnvironment _hostEnvironment;
     private readonly ProfilingTelemetry _profilingTelemetry;
+    private readonly TimeProvider _timeProvider;
     private bool _isDetachMode;
     private const int MaxDisplayedAppHostStartupOutputLines = 80;
 
+    private static readonly TimeSpan s_appHostStartupCancellationTimeout = 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.
@@ -107,7 +110,8 @@ public RunCommand(
         AppHostLauncher appHostLauncher,
         FileLoggerProvider fileLoggerProvider,
         ICliHostEnvironment hostEnvironment,
-        ProfilingTelemetry profilingTelemetry)
+        ProfilingTelemetry profilingTelemetry,
+        TimeProvider timeProvider)
         : base("run", RunCommandStrings.Description, features, updateNotifier, executionContext, interactionService, telemetry)
     {
         _runner = runner;
@@ -123,6 +127,7 @@ public RunCommand(
         _fileLoggerProvider = fileLoggerProvider;
         _hostEnvironment = hostEnvironment;
         _profilingTelemetry = profilingTelemetry;
+        _timeProvider = timeProvider;
 
         Options.Add(s_detachOption);
         Options.Add(s_noBuildOption);
@@ -168,10 +173,15 @@ protected override async Task<CommandResult> ExecuteAsync(ParseResult parseResul
             return CommandResult.Failure(CliExitCodes.InvalidCommand, RunCommandStrings.NoBuildNotSupportedWithWatchMode);
         }
 
+        if (!AppHostStartupTimeout.TryGetTimeoutSeconds(_configuration, InteractionService, out var timeoutSeconds))
+        {
+            return CommandResult.Failure(CliExitCodes.InvalidCommand);
+        }
+
         // Handle detached mode - spawn child process and exit
         if (detach)
         {
-            return await ExecuteDetachedAsync(parseResult, passedAppHostProjectFile, isExtensionHost, cancellationToken);
+            return await ExecuteDetachedAsync(parseResult, passedAppHostProjectFile, isExtensionHost, timeoutSeconds, cancellationToken);
         }
 
         // A user may run `aspire run` in an Aspire terminal in VS Code. In this case, intercept and prompt
@@ -277,16 +287,29 @@ protected override async Task<CommandResult> ExecuteAsync(ParseResult parseResul
 
             // Start the project run as a pending task - we'll handle UX while it runs
             Task<int> pendingRun;
+            var startupTimeout = TimeSpan.FromSeconds(timeoutSeconds);
+            var startupStartTimestamp = _timeProvider.GetTimestamp();
+            using var runCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
             using (_profilingTelemetry.StartRunAppHostStartProject(project.LanguageId, noBuild, waitForDebugger))
             {
-                pendingRun = project.RunAsync(context, cancellationToken);
+                pendingRun = project.RunAsync(context, runCancellationTokenSource.Token);
             }
 
             // Wait for the build to complete first (project handles its own build status spinners)
             bool buildSuccess;
             using (var waitForBuildActivity = _profilingTelemetry.StartRunAppHostWaitForBuild())
             {
-                buildSuccess = await buildCompletionSource.Task.WaitAsync(cancellationToken);
+                try
+                {
+                    buildSuccess = await buildCompletionSource.Task.WaitAsync(GetRemainingStartupTimeout(startupStartTimestamp, startupTimeout), _timeProvider, cancellationToken);
+                }
+                catch (TimeoutException)
+                {
+                    runActivity?.SetTag(TelemetryConstants.Tags.ErrorType, "startup_timeout");
+                    await CancelAppHostStartupAsync(runCancellationTokenSource, pendingRun).ConfigureAwait(false);
+                    return CreateStartupTimeoutResult(timeoutSeconds);
+                }
+
                 waitForBuildActivity.SetAppHostBuildSuccess(buildSuccess);
             }
             if (!buildSuccess)
@@ -312,13 +335,25 @@ protected override async Task<CommandResult> ExecuteAsync(ParseResult parseResul
 
             try
             {
-                var startup = await WaitForAppHostStartupAsync(
-                    pendingRun,
-                    backchannelCompletionSource,
-                    logCaptureCancellationSource,
-                    context.OutputCollector,
-                    appHostStartupOutputStartIndex,
-                    cancellationToken).ConfigureAwait(false);
+                AppHostStartupResult startup;
+                try
+                {
+                    startup = await WaitForAppHostStartupAsync(
+                        pendingRun,
+                        backchannelCompletionSource,
+                        logCaptureCancellationSource,
+                        context.OutputCollector,
+                        appHostStartupOutputStartIndex,
+                        startupStartTimestamp,
+                        startupTimeout,
+                        cancellationToken).ConfigureAwait(false);
+                }
+                catch (TimeoutException)
+                {
+                    runActivity?.SetTag(TelemetryConstants.Tags.ErrorType, "startup_timeout");
+                    await CancelAppHostStartupAsync(runCancellationTokenSource, pendingRun).ConfigureAwait(false);
+                    return CreateStartupTimeoutResult(timeoutSeconds);
+                }
 
                 var backchannel = startup.Backchannel;
                 var dashboardUrls = startup.DashboardUrls;
@@ -471,6 +506,15 @@ await InteractionService.DisplayLiveAsync(BuildLiveRenderable(), async updateTar
                         : CommandResult.FromExitCode(exitCode);
                 }
             }
+            catch (OperationCanceledException ex) when (ex.CancellationToken == runCancellationTokenSource.Token && cancellationToken.IsCancellationRequested)
+            {
+                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.
+                return CommandResult.Cancelled(CliExitCodes.Success);
+            }
             finally
             {
                 logCaptureCancellationSource.Cancel();
@@ -643,10 +687,12 @@ private async Task<AppHostStartupResult> WaitForAppHostStartupAsync(
         CancellationTokenSource logCaptureCancellationSource,
         OutputCollector? outputCollector,
         int appHostStartupOutputStartIndex,
+        long startupStartTimestamp,
+        TimeSpan startupTimeout,
         CancellationToken cancellationToken)
     {
         using var startupCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-        var happyPathTask = RunStartupHappyPathAsync(backchannelCompletionSource, logCaptureCancellationSource, pendingRun, startupCts.Token);
+        var happyPathTask = RunStartupHappyPathAsync(backchannelCompletionSource, logCaptureCancellationSource, pendingRun, startupStartTimestamp, startupTimeout, startupCts.Token);
 
         // Race the startup readiness signal against the AppHost system task. The AppHost
         // system is owned by the project and tears itself down (via an internal escalation
@@ -690,6 +736,13 @@ private async Task<AppHostStartupResult> WaitForAppHostStartupAsync(
             DisplayRecentAppHostStartupOutput(InteractionService, outputCollector, appHostStartupOutputStartIndex);
             throw;
         }
+        catch (TimeoutException)
+        {
+            // Bubble startup-timeout signal up to ExecuteAsync so it can cancel the run
+            // and emit the localized timeout guidance. Must not be wrapped by the generic
+            // catch below.
+            throw;
+        }
         catch (Exception ex) when (ex is not OperationCanceledException)
         {
             var failureMessage = string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.UnexpectedErrorOccurred, ex.Message);
@@ -720,14 +773,16 @@ private async Task<AppHostStartupResult> RunStartupHappyPathAsync(
         TaskCompletionSource<IAppHostCliBackchannel> backchannelCompletionSource,
         CancellationTokenSource logCaptureCancellationSource,
         Task<int> pendingRun,
+        long startupStartTimestamp,
+        TimeSpan startupTimeout,
         CancellationToken cancellationToken)
     {
         IAppHostCliBackchannel backchannel;
         using (var waitForBackchannelActivity = _profilingTelemetry.StartRunAppHostWaitForBackchannel())
         {
             backchannel = await InteractionService.ShowStatusAsync(
                 RunCommandStrings.ConnectingToAppHost,
-                async () => await backchannelCompletionSource.Task.WaitAsync(cancellationToken).ConfigureAwait(false));
+                async () => await backchannelCompletionSource.Task.WaitAsync(GetRemainingStartupTimeout(startupStartTimestamp, startupTimeout), _timeProvider, cancellationToken).ConfigureAwait(false));
             waitForBackchannelActivity.SetAppHostBackchannelConnected(true);
         }
 
@@ -1027,12 +1082,12 @@ public void ProcessResourceState(RpcResourceState resourceState, Action<string,
     /// with the poll delay. Shows exit code and log file path.
     /// Returns <see cref="CliExitCodes.FailedToDotnetRunAppHost"/>.</item>
     /// <item><b>Timeout waiting for backchannel</b>: The auxiliary backchannel socket doesn't appear
-    /// within 120 seconds. The child process is killed. Shows timeout message and log file path.
+    /// within the configured startup timeout. The child process is killed. Shows timeout message and log file path.
     /// Returns <see cref="CliExitCodes.FailedToDotnetRunAppHost"/>.</item>
     /// </list>
     /// <para>On any failure, the log file path is displayed so the user can investigate.</para>
     /// </remarks>
-    private Task<CommandResult> ExecuteDetachedAsync(ParseResult parseResult, FileInfo? passedAppHostProjectFile, bool isExtensionHost, CancellationToken cancellationToken)
+    private Task<CommandResult> ExecuteDetachedAsync(ParseResult parseResult, FileInfo? passedAppHostProjectFile, bool isExtensionHost, int timeoutSeconds, CancellationToken cancellationToken)
     {
         var format = parseResult.GetValue(AppHostLauncher.s_formatOption);
         var isolated = parseResult.GetValue(AppHostLauncher.s_isolatedOption);
@@ -1056,10 +1111,58 @@ private Task<CommandResult> ExecuteDetachedAsync(ParseResult parseResult, FileIn
             isolated,
             isExtensionHost,
             waitForDebugger,
+            timeoutSeconds,
             globalArgs,
             additionalArgs,
             stopAfterLaunchDelay,
             cancellationToken);
     }
 
+    private TimeSpan GetRemainingStartupTimeout(long startupStartTimestamp, TimeSpan startupTimeout)
+    {
+        var elapsed = _timeProvider.GetElapsedTime(startupStartTimestamp);
+        return elapsed >= startupTimeout ? TimeSpan.Zero : startupTimeout - elapsed;
+    }
+
+    private async Task CancelAppHostStartupAsync(CancellationTokenSource runCancellationTokenSource, Task<int> pendingRun)
+    {
+        runCancellationTokenSource.Cancel();
+
+        try
+        {
+            await pendingRun.WaitAsync(s_appHostStartupCancellationTimeout, _timeProvider).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) when (runCancellationTokenSource.IsCancellationRequested)
+        {
+        }
+        catch (TimeoutException ex)
+        {
+            _logger.LogDebug(ex, "Timed out waiting for AppHost startup cancellation to complete.");
+            _ = ObserveAppHostRunFailureAsync(pendingRun);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "AppHost run failed after startup cancellation.");
+        }
+    }
+
+    private async Task ObserveAppHostRunFailureAsync(Task<int> pendingRun)
+    {
+        try
+        {
+            await pendingRun.ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "AppHost run failed after startup cancellation timeout.");
+        }
+    }
+
+    private static CommandResult CreateStartupTimeoutResult(int timeoutSeconds)
+    {
+        return CommandResult.Failure(
+            CliExitCodes.FailedToDotnetRunAppHost,
+            string.Format(CultureInfo.CurrentCulture, RunCommandStrings.TimeoutWaitingForAppHost, timeoutSeconds, CliConfigNames.AppHostStartupTimeout));
+    }
+
 }

src/Aspire.Cli/Commands/StartCommand.cs

@@ -133,12 +133,18 @@ await extensionInteractionService.StartDebugSessionAsync(
             additionalArgs.Add("--no-build");
         }
 
+        if (!AppHostStartupTimeout.TryGetTimeoutSeconds(_configuration, InteractionService, out var timeoutSeconds))
+        {
+            return CommandResult.Failure(CliExitCodes.InvalidCommand);
+        }
+
         return await _appHostLauncher.LaunchDetachedAsync(
             passedAppHostProjectFile,
             format,
             isolated,
             isExtensionHost,
             waitForDebugger,
+            timeoutSeconds,
             globalArgs,
             additionalArgs,
             stopAfterLaunchDelay,

src/Aspire.Cli/Commands/WaitCommand.cs

@@ -34,10 +34,12 @@ internal sealed class WaitCommand : BaseCommand
         DefaultValueFactory = _ => "healthy"
     };
 
+    internal const int DefaultTimeoutSeconds = 120;
+
     private static readonly Option<int> s_timeoutOption = new("--timeout")
     {
         Description = WaitCommandStrings.TimeoutOptionDescription,
-        DefaultValueFactory = _ => 120
+        DefaultValueFactory = _ => DefaultTimeoutSeconds
     };
 
     private static readonly OptionWithLegacy<FileInfo?> s_appHostOption = new("--apphost", "--project", SharedCommandStrings.AppHostOptionDescription);