Add CommandExceptionHandler

src/Spectre.Console.Cli/CommandExceptionArgs.cs

@@ -0,0 +1,30 @@
+namespace Spectre.Console.Cli;
+#pragma warning restore S2326
+
+/// <summary>
+/// Represents the args for a command exception.
+/// </summary>
+public readonly struct CommandExceptionArgs
+{
+    /// <summary>
+    /// Gets the command context.
+    /// </summary>
+    public CommandContext Context { get; }
+
+    /// <summary>
+    /// Gets the exception that was thrown.
+    /// </summary>
+    public Exception Exception { get; }
+
+    /// <summary>
+    /// Gets the command type.
+    /// </summary>
+    public Type? CommandType { get; }
+
+    internal CommandExceptionArgs(CommandContext context, Exception exception, Type? commandType)
+    {
+        Context = context;
+        Exception = exception;
+        CommandType = commandType;
+    }
+}

src/Spectre.Console.Cli/ICommandExceptionHandler.cs

@@ -0,0 +1,26 @@
+namespace Spectre.Console.Cli;
+
+/// <summary>
+/// Represents an args handler.
+/// Exception handlers are used to handle exceptions that occur during command execution.
+/// </summary>
+public interface ICommandExceptionHandler
+{
+    /// <summary>
+    /// Handles the specified args.
+    /// </summary>
+    /// <param name="args">The args to handle.</param>
+    /// <returns><c>true</c> if the args was handled, otherwise <c>false</c>.</returns>
+    bool Handle(CommandExceptionArgs args);
+}
+
+/// <summary>
+/// Represents an args handler for a specific command.
+/// </summary>
+/// <typeparam name="TCommand">Type of the command.</typeparam>
+// ReSharper disable once UnusedTypeParameter
+#pragma warning disable S2326
+public interface ICommandExceptionHandler<TCommand> : ICommandExceptionHandler
+    where TCommand : ICommand
+{
+}

src/Spectre.Console.Cli/Internal/CommandExceptionHandler.cs

@@ -0,0 +1,75 @@
+using Spectre.Console.Cli.Internal.Extensions;
+
+namespace Spectre.Console.Cli.Internal;
+
+internal static class CommandExceptionHandler
+{
+    public static bool HandleException(
+        CommandTree leaf,
+        CommandContext context,
+        ITypeResolver resolver,
+        Exception ex)
+    {
+        var args = new CommandExceptionArgs(context, ex, leaf?.Command?.CommandType);
+
+        if (leaf?.Command?.CommandType == null)
+        {
+            return TryInvokeHandler(
+                resolver,
+                args,
+                typeof(IEnumerable<ICommandExceptionHandler>),
+                typeof(ICommandExceptionHandler));
+        }
+
+        var handlerType = typeof(ICommandExceptionHandler<>)
+            .MakeGenericType(leaf.Command.CommandType);
+
+        var enumerableHandlerType = typeof(IEnumerable<>)
+            .MakeGenericType(handlerType);
+
+        var handled = TryInvokeHandler(resolver, args, enumerableHandlerType, handlerType);
+        if (handled)
+        {
+            return true;
+        }
+
+        return TryInvokeHandler(resolver, args, typeof(IEnumerable<ICommandExceptionHandler>),
+            typeof(ICommandExceptionHandler));
+    }
+
+    private static bool TryInvokeHandler(
+        ITypeResolver resolver,
+        CommandExceptionArgs args,
+        Type enumerableHandlerType,
+        Type handlerType)
+    {
+        var handlers = resolver.TryResolve(enumerableHandlerType);
+        if (handlers is IEnumerable<ICommandExceptionHandler> exHandlerEnumerable)
+        {
+            foreach (var exHandlerItem in exHandlerEnumerable)
+            {
+                var isHandled = exHandlerItem.Handle(args);
+                if (isHandled)
+                {
+                    return true;
+                }
+            }
+        }
+        else
+        {
+            var handler = resolver.TryResolve(handlerType);
+            if (handler is not ICommandExceptionHandler exHandler)
+            {
+                return false;
+            }
+
+            var isHandled = exHandler.Handle(args);
+            if (isHandled)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/Spectre.Console.Cli/Internal/CommandExecutor.cs

@@ -1,3 +1,5 @@
+using Spectre.Console.Cli.Internal;
+
 namespace Spectre.Console.Cli;
 
 internal sealed class CommandExecutor
@@ -121,26 +123,40 @@ private static string ResolveApplicationVersion(IConfiguration configuration)
             VersionHelper.GetVersion(Assembly.GetEntryAssembly());
     }
 
-    private static Task<int> Execute(
+    private static async Task<int> Execute(
         CommandTree leaf,
         CommandTree tree,
         CommandContext context,
         ITypeResolver resolver,
         IConfiguration configuration)
     {
-        // Bind the command tree against the settings.
-        var settings = CommandBinder.Bind(tree, leaf.Command.SettingsType, resolver);
-        configuration.Settings.Interceptor?.Intercept(context, settings);
-
-        // Create and validate the command.
-        var command = leaf.CreateCommand(resolver);
-        var validationResult = command.Validate(context, settings);
-        if (!validationResult.Successful)
+        try
         {
-            throw CommandRuntimeException.ValidationFailed(validationResult);
+            // Bind the command tree against the settings.
+            var settings = CommandBinder.Bind(tree, leaf.Command.SettingsType, resolver);
+            configuration.Settings.Interceptor?.Intercept(context, settings);
+
+            // Create and validate the command.
+            var command = leaf.CreateCommand(resolver);
+            var validationResult = command.Validate(context, settings);
+            if (!validationResult.Successful)
+            {
+                throw CommandRuntimeException.ValidationFailed(validationResult);
+            }
+
+            // Execute the command.
+            return await command.Execute(context, settings);
         }
+        catch (Exception ex)
+        {
+            var handled = CommandExceptionHandler.HandleException(leaf, context, resolver, ex);
+            if (handled)
+            {
+                return -1;
+            }
 
-        // Execute the command.
-        return command.Execute(context, settings);
-    }
+            // Exception will be re-thrown and original stack trace will be preserved
+            throw;
+        }
+    }
 }

src/Spectre.Console.Cli/Internal/Extensions/TypeResolverExtensions.cs

@@ -0,0 +1,31 @@
+namespace Spectre.Console.Cli.Internal.Extensions;
+
+internal static class TypeResolverExtensions
+{
+    public static object? TryResolve(this ITypeResolver resolver, Type type)
+    {
+        if (resolver == null)
+        {
+            throw new ArgumentNullException(nameof(resolver));
+        }
+
+        if (type == null)
+        {
+            throw new ArgumentNullException(nameof(type));
+        }
+
+        if (resolver is TypeResolverAdapter adapter)
+        {
+            return adapter.TryResolve(type);
+        }
+
+        try
+        {
+            return resolver.Resolve(type);
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+}

src/Spectre.Console.Cli/Internal/TypeResolverAdapter.cs

@@ -37,6 +37,23 @@ public TypeResolverAdapter(ITypeResolver? resolver)
         }
     }
 
+    public object? TryResolve(Type? type)
+    {
+        if (type == null)
+        {
+            throw new CommandRuntimeException("Cannot resolve null type.");
+        }
+
+        try
+        {
+            return _resolver?.Resolve(type);
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+
     public void Dispose()
     {
         if (_resolver is IDisposable disposable)