Add console command and version management features

This commit introduces the `ConsoleCommand` for executing the FlowSynx console, along with options for specifying an address. A new `ConsoleVersionCommand` is added to retrieve and display the console version.

New classes `ConsoleCommandOptions` and `ConsoleVersionCommandOptions` are created to manage command options, while their respective handlers handle execution and logging.

Localized strings for error messages and command descriptions are added, and the `ServiceCollectionExtensions` class is updated to register the new commands. Minor corrections to existing resource strings enhance clarity and consistency.

#107

Author: ziagham

src/FlowCtl/Commands/Console/ConsoleCommand.cs

@@ -0,0 +1,16 @@
+using FlowCtl.Commands.Console.Version;
+using System.CommandLine;
+
+namespace FlowCtl.Commands.Console;
+
+internal class ConsoleCommand : BaseCommand<ConsoleCommandOptions, ConsoleCommandOptionsHandler>
+{
+    public ConsoleCommand() : base("console", Resources.Command_Console_Description)
+    {
+        var addressOption = new Option<string?>(new[] { "-a", "--address" },
+            description: Resources.Commands_FlowSynxAddress);
+
+        AddOption(addressOption);
+        AddCommand(new ConsoleVersionCommand());
+    }
+}

src/FlowCtl/Commands/Console/ConsoleCommandOptions.cs

@@ -0,0 +1,6 @@
+namespace FlowCtl.Commands.Console;
+
+internal class ConsoleCommandOptions : ICommandOptions
+{
+    public string? Address { get; set; } = string.Empty;
+}

src/FlowCtl/Commands/Console/ConsoleCommandOptionsHandler.cs

@@ -0,0 +1,83 @@
+using FlowCtl.Core.Services.Location;
+using FlowCtl.Core.Services.Logger;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace FlowCtl.Commands.Console;
+
+internal class ConsoleCommandOptionsHandler : ICommandOptionsHandler<ConsoleCommandOptions>
+{
+    private readonly IFlowCtlLogger _flowCtlLogger;
+    private readonly ILocation _location;
+
+    public ConsoleCommandOptionsHandler(
+        IFlowCtlLogger flowCtlLogger,
+        ILocation location)
+    {
+        _flowCtlLogger = flowCtlLogger ?? throw new ArgumentNullException(nameof(flowCtlLogger));
+        _location = location;
+    }
+
+    public async Task<int> HandleAsync(ConsoleCommandOptions options, CancellationToken cancellationToken)
+    {
+        await Execute(options);
+        return 0;
+    }
+
+    private Task Execute(ConsoleCommandOptions options)
+    {
+        try
+        {
+            var dashboardPath = Path.Combine(_location.DefaultFlowSynxBinaryDirectoryName, "console");
+            var dashboardBinaryFile = _location.LookupConsoleBinaryFilePath(dashboardPath);
+            if (!Path.Exists(dashboardBinaryFile))
+            {
+                _flowCtlLogger.WriteError(Resources.Command_Console_ConsleIsNotInstalled);
+                return Task.CompletedTask;
+            }
+
+            var startInfo = new ProcessStartInfo(dashboardBinaryFile)
+            {
+                Arguments = GetArgumentStr(options),
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                WorkingDirectory = dashboardPath
+            };
+
+            var process = new Process { StartInfo = startInfo };
+            process.OutputDataReceived += OutputDataHandler;
+            process.ErrorDataReceived += ErrorDataHandler;
+            var processStarted = process.Start();
+
+            process.BeginOutputReadLine();
+            process.BeginErrorReadLine();
+            process?.WaitForExit();
+        }
+        catch (Exception e)
+        {
+            _flowCtlLogger.WriteError(e.Message);
+        }
+        return Task.CompletedTask;
+    }
+
+    private string GetArgumentStr(ConsoleCommandOptions options)
+    {
+        var argList = new List<string>();
+
+        if (!string.IsNullOrEmpty(options.Address))
+            argList.Add($"--address {options.Address}");
+
+        return argList.Count == 0 ? string.Empty : string.Join(' ', argList);
+    }
+
+    private void OutputDataHandler(object sendingProcess, DataReceivedEventArgs outLine)
+    {
+        if (outLine.Data != null) _flowCtlLogger.Write(outLine.Data);
+    }
+
+    private void ErrorDataHandler(object sendingProcess, DataReceivedEventArgs outLine)
+    {
+        if (outLine.Data != null) _flowCtlLogger.WriteError(outLine.Data);
+    }
+}

src/FlowCtl/Commands/Console/Version/ConsoleVersionCommand.cs

@@ -0,0 +1,16 @@
+using FlowCtl.Core.Services.Logger;
+using System.CommandLine;
+
+namespace FlowCtl.Commands.Console.Version;
+
+internal class ConsoleVersionCommand : BaseCommand<ConsoleVersionCommandOptions, ConsoleVersionCommandOptionsHandler>
+{
+    public ConsoleVersionCommand() : base("version", Resources.Command_ConsoleVersion_Description)
+    {
+        var outputOption = new Option<OutputType>(new[] { "-o", "--output" },
+            getDefaultValue: () => OutputType.Json,
+            description: Resources.Commands_Output_Format);
+
+        AddOption(outputOption);
+    }
+}

src/FlowCtl/Commands/Console/Version/ConsoleVersionCommandOptions.cs

@@ -0,0 +1,8 @@
+using FlowCtl.Core.Services.Logger;
+
+namespace FlowCtl.Commands.Console.Version;
+
+internal class ConsoleVersionCommandOptions : ICommandOptions
+{
+    public OutputType Output { get; set; } = OutputType.Json;
+}

src/FlowCtl/Commands/Console/Version/ConsoleVersionCommandOptionsHandler.cs

@@ -0,0 +1,52 @@
+using FlowCtl.Core.Services.Location;
+using FlowCtl.Core.Services.Logger;
+using FlowCtl.Services.Version;
+
+namespace FlowCtl.Commands.Console.Version;
+
+internal class ConsoleVersionCommandOptionsHandler : ICommandOptionsHandler<ConsoleVersionCommandOptions>
+{
+    private readonly IFlowCtlLogger _flowCtlLogger;
+    private readonly ILocation _location;
+    private readonly IVersion _version;
+
+    public ConsoleVersionCommandOptionsHandler(IFlowCtlLogger flowCtlLogger,
+        ILocation location, IVersion version)
+    {
+        _flowCtlLogger = flowCtlLogger ?? throw new ArgumentNullException(nameof(flowCtlLogger));
+        _location = location ?? throw new ArgumentNullException(nameof(location));
+        _version = version ?? throw new ArgumentNullException(nameof(version));
+    }
+
+    public Task<int> HandleAsync(ConsoleVersionCommandOptions options, CancellationToken cancellationToken)
+    {
+        Execute(options);
+        return Task.FromResult(0);
+    }
+
+    private Task Execute(ConsoleVersionCommandOptions options)
+    {
+        try
+        {
+            var fullVersion = new
+            {
+                Version = GetConsoleVersion()
+            };
+
+            _flowCtlLogger.Write(fullVersion, options.Output);
+            return Task.CompletedTask;
+        }
+        catch (Exception ex)
+        {
+            _flowCtlLogger.WriteError(ex.Message);
+            return Task.CompletedTask;
+        }
+    }
+
+    private string GetConsoleVersion()
+    {
+        var consoleBinaryFile = _location.LookupConsoleBinaryFilePath(Path.Combine(_location.DefaultFlowSynxBinaryDirectoryName, "console"));
+        var consoleVersion = _version.GetVersionFromPath(consoleBinaryFile);
+        return string.IsNullOrEmpty(consoleVersion) ? Resources.Commands_Version_NotInitialized : consoleVersion;
+    }
+}

src/FlowCtl/Extensions/ServiceCollectionExtensions.cs

@@ -27,6 +27,7 @@
 using FlowSynx.Client;
 using Spectre.Console;
 using FlowSynx.Client.Authentication;
+using FlowCtl.Commands.Console;
 
 namespace FlowCtl.Extensions;
 
@@ -43,6 +44,7 @@ public static IServiceCollection AddCommands(this IServiceCollection services)
     {
         services.AddTransient<RootCommand, Root>()
                 .AddTransient<Command, ConfigCommand>()
+                .AddTransient<Command, ConsoleCommand>()
                 .AddTransient<Command, HealthCommand>()
                 .AddTransient<Command, InitCommand>()
                 .AddTransient<Command, LoginCommand>()