Move error handling from Program.cs to BaseCommand SetAction delegate

src/Aspire.Cli/Commands/BaseCommand.cs

@@ -15,6 +15,8 @@ namespace Aspire.Cli.Commands;
 
 internal abstract class BaseCommand : Command
 {
+    private static readonly int[] s_suppressErrorLogsMessageExitCodes = [CliExitCodes.Cancelled, CliExitCodes.MissingRequiredArgument];
+
     protected virtual bool UpdateNotificationsEnabled { get; } = true;
 
     /// <summary>
@@ -60,6 +62,16 @@ protected BaseCommand(string name, string description, IFeatures features, ICliU
                 // Error messages have already been displayed by the interaction service.
                 result = CommandResult.Failure(CliExitCodes.MissingRequiredArgument);
             }
+            catch (OperationCanceledException ex) when (cancellationToken.IsCancellationRequested || ex is ExtensionOperationCanceledException)
+            {
+                result = CommandResult.Cancelled();
+            }
+            catch (Exception ex)
+            {
+                var errorMessage = string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.UnexpectedErrorOccurred, ex.Message);
+                telemetry.RecordError(errorMessage, ex);
+                result = CommandResult.Failure(CliExitCodes.InvalidCommand, errorMessage);
+            }
 
             var isErrorExitCode = result.ExitCode != CliExitCodes.Success;
 
@@ -82,7 +94,7 @@ protected BaseCommand(string name, string description, IFeatures features, ICliU
             // Display the CLI log file path on non-zero exit codes so the user knows
             // where to find diagnostic details. Suppress for user-input errors where
             // the log wouldn't contain useful context (e.g., missing required arguments).
-            if (isErrorExitCode && result.ExitCode != CliExitCodes.MissingRequiredArgument)
+            if (isErrorExitCode && !s_suppressErrorLogsMessageExitCodes.Contains(result.ExitCode))
             {
                 interactionService.DisplayMessage(
                     KnownEmojis.PageFacingUp,

src/Aspire.Cli/Program.cs

@@ -865,12 +865,9 @@ public static async Task<int> Main(string[] args)
                 // Log exit code for debugging
                 logger.LogInformation("Exit code: {ExitCode}", exitCode);
             }
-            catch (OperationCanceledException ex) when (cancellationManager.IsCancellationRequested || ex is ExtensionOperationCanceledException)
-            {
-                exitCode = CliExitCodes.Cancelled;
-            }
             catch (Exception ex)
             {
+                // Should never get here because RootCommand's handler should catch all exceptions, but log just in case.
                 exitCode = CliExitCodes.InvalidCommand;
 
                 logger.LogError(ex, "An unexpected error occurred.");

tests/Aspire.Cli.Tests/Commands/BaseCommandTests.cs

@@ -270,4 +270,39 @@ public async Task BaseCommand_OnSuccess_DoesNotDisplayLogFilePath()
         Assert.DoesNotContain(testInteractionService.DisplayedMessages,
             m => m.ConsoleOverride == ConsoleOutput.Error);
     }
+
+    [Fact]
+    public async Task BaseCommand_OnUnexpectedException_ReturnsInvalidCommandExitCode_AndDisplaysError()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var testInteractionService = new TestInteractionService();
+        var backchannelMonitor = new TestAuxiliaryBackchannelMonitor
+        {
+            ScanAsyncCallback = _ => throw new InvalidOperationException("Something went wrong")
+        };
+
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.InteractionServiceFactory = _ => testInteractionService;
+            options.AuxiliaryBackchannelMonitorFactory = _ => backchannelMonitor;
+        });
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("ps");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.InvalidCommand, exitCode);
+
+        // Verify error message was displayed
+        var expectedErrorMessage = string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.UnexpectedErrorOccurred, "Something went wrong");
+        Assert.Contains(expectedErrorMessage, testInteractionService.DisplayedErrors);
+
+        // Verify log file path was displayed on stderr
+        var executionContext = provider.GetRequiredService<CliExecutionContext>();
+        var expectedLogMessage = string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.SeeLogsAt, executionContext.LogFilePath);
+        var logMessage = Assert.Single(testInteractionService.DisplayedMessages, m => m.Message == expectedLogMessage);
+        Assert.Equal(ConsoleOutput.Error, logMessage.ConsoleOverride);
+    }
 }