Access Settings Prior to Comamnd Run

[MrHinsh]

I'm running the commands within a Host, and during setup of the host, I need to get the value of --config so that it can be added to the configuration during the host's setup.

Would there be an easy/elegant way to grab the parsed CommandSettings?

I'm thinking that a really hacky way to do this would be to have a fake CommandApp that I run first to grab the settings, and then launch the rest of the app.

What I would prefer is some way to parse settings from the Args outside of the main system.

 ExecuteMigrationCommandSettings tempSettings = Spectre.Console.Cli.CommandApp.Parse<ExecuteMigrationCommandSettings>(args)

I'll be throwing away this object, but I would let me grab some context for how the application is setup before the CommandApp is loaded.

[MrHinsh]

Ive found a nasty solution! Not proud of it!

I created a ForceGetConfigFile that uses the System.CommandLine capability to parse out that single value.

using System.ComponentModel;
using Newtonsoft.Json;
using Spectre.Console.Cli;
using YamlDotNet.Serialization;
using System.CommandLine;

namespace MigrationTools.Host.Commands
{
    internal class CommandSettingsBase : CommandSettings
    {
        [Description("Pre configure paramiters using this config file. Run `Init` to create it.")]
        [CommandOption("--config|--configFile|-c")]
        [DefaultValue("configuration.json")]
        [JsonIgnore, YamlIgnore]
        public string ConfigFile { get; set; }

        [Description("Add this paramiter to turn Telemetry off")]
        [CommandOption("--disableTelemetry")]
        public bool DisableTelemetry { get; set; }

        [Description("Add this paramiter to turn version check off")]
        [CommandOption("--skipVersionCheck")]
        public bool skipVersionCheck { get; set; }

        public static string ForceGetConfigFile(string[] args)
        {
            var fileOption = new Option<string?>("--config");
            fileOption.AddAlias("-c");
            fileOption.AddAlias("--configFile");

            var rootCommand = new RootCommand();
            rootCommand.AddOption(fileOption);

            var file = rootCommand.Parse(args);
            return file.GetValueForOption<string>(fileOption);

        }
    }

}

[elgonzo]

While i haven't done anything like this myself, wouldn't ICommandInterceptor address your problem? See the (unfortunately brief) documentation here: https://spectreconsole.net/cli/commandapp#interception and https://spectreconsole.net/api/spectre.console.cli/icommandinterceptor/

[MrHinsh]

Yeah I read the documentation there and I really couldn't make enough sense of it to understand how I would use it within the context of a host.

[patriksvensson]

I'm having trouble understanding what you're trying to accomplish. Could you provide a use case for this pre-parsing method?

[MrHinsh]

Sure...

In order to configure the IHostBuilder all of the services, including CommandApp needs to be configured.

hostBuilder.ConfigureServices((context, services) =>
{
    using var registrar = new DependencyInjectionRegistrar(services);
    var app = new CommandApp(registrar);
    app.Configure(config =>
    {
        config.PropagateExceptions();
        config.AddCommand<Commands.ExecuteMigrationCommand>("execute");
        config.AddCommand<Commands.InitMigrationCommand>("init");

    });
    services.AddSingleton<ICommandApp>(app);
});

During that same setup I need to also inject the configuration file specified on the settings so that

 hostBuilder.ConfigureAppConfiguration(builder =>
 {
     if (!string.IsNullOrEmpty(configFile) &&  File.Exists(configFile))
     {
         builder.AddJsonFile(configFile);
     }
 });

The configFile is specified on the args as part of the base command fro both execute and init.

[nils-a]

If you're working with the generic IHost, have you taken a look at what this 3rd-party extension can do for you: https://github.com/juro-org/Spectre.Console.Extensions.Hosting?

As far as I know, it was designed to easily configure spectre.console when using the generic IHost.

[MrHinsh]

Yes. I already use spectre.cli.extensions.dependencyinjection, but neither is an answer to the question.

I did swap out to the newer one you mentioned:}

   hostBuilder.UseSpectreConsole(config =>
   {
       config.AddCommand<Commands.ExecuteMigrationCommand>("execute");
       config.AddCommand<Commands.InitMigrationCommand>("init");
       config.PropagateExceptions();
   });

But still need access to the settings outside of the execution of the command so that I can feed it into the overall configuration of the service.

[devdilmun]

I found something a little bit cleaner. Create a fake command that uses a settings class derived from the one you want. Add enough positional arguments to soak up your actual commands:

public class ActualSettingsClass: CommandSettings { }

public class FakeCommand : Command<FakeCommand.Settings>
{
    public class Settings : ActualSettingsClass
    {
        [CommandArgument(0, "[Arg]")]
        public string? Pos0 { get; set; }
        [CommandArgument(1, "[Arg]")]
        public string? Pos1 { get; set; }
        [CommandArgument(2, "[Arg]")]
        public string? Pos2 { get; set; }
        [CommandArgument(3, "[Arg]")]
        public string? Pos3 { get; set; }
        [CommandArgument(4, "[Arg]")]
        public string? Pos4 { get; set; }
        [CommandArgument(5, "[Arg]")]
        public string? Pos5 { get; set; }
        [CommandArgument(6, "[Arg]")]
        public string? Pos6 { get; set; }
        [CommandArgument(7, "[Arg]")]
        public string? Pos7 { get; set; }
        [CommandArgument(8, "[Arg]")]
        public string? Pos8 { get; set; }
        [CommandArgument(9, "[Arg]")]
        public string? Pos9 { get; set; }

    }

    // The commands come through as positional and the command options still get parsed. Grab the Settings object...
    public override int Execute(CommandContext context, Settings settings)
    {
        Program.Settings = settings;
        return 0;
    }
}

Set this to a static property in your Program.cs or use in anything static:

public class Program
{

    internal static FakeCommand.Settings Settings { get; set; } = new FakeCommand.Settings();
    
    public static void Main(string[] args)
    {
        var getSettings = new CommandApp();
        getSettings.SetDefaultCommand<FakeCommand>();
        getSettings.Configure(c => c.Settings.StrictParsing = false);
        getSettings.Run(args)

       . . . Set up and run application
. . .