Add support for additional Docker arguments

Introduced the `AdditionalArguments` property in `DockerRunOptions` to allow specifying extra Docker command arguments.

Added the `GetDockerModeAsync` method to `IDockerService` and implemented it in `DockerService` to dynamically determine the Docker operating system type (Linux, Windows, or Unknown) using the `docker info` command.

Updated `RunContainerAsync` in `DockerService` to include `AdditionalArguments` in Docker commands.

Refactored `InitCommandOptionsHandler` to use `GetDockerModeAsync` for platform detection and set `AdditionalArguments` to `" --start"` when creating Docker containers.

Removed an extraneous closing brace in `InitCommand`.

These changes improve platform-awareness and enhance flexibility in Docker command execution.

#135

Author: ziagham

src/FlowCtl.Core/Models/Docker/DockerRunOptions.cs

@@ -10,4 +10,5 @@ public class DockerRunOptions
     public string HostDataPath { get; set; } = string.Empty;
     public string ContainerDataPath { get; set; } = string.Empty;
     public bool Detached { get; set; } = true;
+    public string? AdditionalArguments { get; set; } = string.Empty;
 }

src/FlowCtl.Core/Services/Docker/IDockerService.cs

@@ -4,6 +4,7 @@ namespace FlowCtl.Core.Services.Docker;
 
 public interface IDockerService
 {
+    Task<string> GetDockerModeAsync(CancellationToken cancellationToken = default);
     Task<bool> IsDockerAvailableAsync(CancellationToken cancellationToken = default);
     Task<DockerCommandResult> PullImageAsync(string imageName, string tag, CancellationToken cancellationToken = default);
     Task<DockerCommandResult> RunContainerAsync(DockerRunOptions options, CancellationToken cancellationToken = default);

src/FlowCtl.Infrastructure/Services/Docker/DockerService.cs

@@ -15,6 +15,24 @@ public DockerService(IFlowCtlLogger flowCtlLogger)
         _flowCtlLogger = flowCtlLogger ?? throw new ArgumentNullException(nameof(flowCtlLogger));
     }
 
+    public async Task<string> GetDockerModeAsync(CancellationToken cancellationToken = default)
+    {
+        var result = await RunDockerAsync(new[] { "info", "--format", "{{.OSType}}" }, streamOutput: false, cancellationToken);
+        if (!result.Success || string.IsNullOrWhiteSpace(result.Output))
+        {
+            return "Unknown";
+        }
+
+        // Docker OSType usually returns "linux" or "windows"
+        var osType = result.Output.Trim().ToLowerInvariant();
+        return osType switch
+        {
+            "linux" => "Linux",
+            "windows" => "Windows",
+            _ => "Unknown"
+        };
+    }
+
     public Task<bool> IsDockerAvailableAsync(CancellationToken cancellationToken = default)
     {
         return ContainerQueryAsync(new[] { "info" }, cancellationToken);
@@ -65,6 +83,11 @@ public Task<DockerCommandResult> RunContainerAsync(DockerRunOptions options, Can
 
         arguments.Add($"{options.ImageName}:{options.Tag}");
 
+        if (!string.IsNullOrWhiteSpace(options.AdditionalArguments))
+        {
+            arguments.AddRange(options.AdditionalArguments.Split(' ', StringSplitOptions.RemoveEmptyEntries));
+        }
+
         return RunDockerAsync(arguments, streamOutput: true, cancellationToken);
     }
 

src/FlowCtl/Commands/Init/InitCommand.cs

@@ -39,4 +39,4 @@ public InitCommand() : base("init", Resources.Commands_Init_Description)
         AddOption(mountOption);
         AddOption(containerPathOption);
     }
-}
+}

src/FlowCtl/Commands/Init/InitCommandOptionsHandler.cs

@@ -135,7 +135,7 @@ private async Task InitializeDockerAsync(InitCommandOptions options, Cancellatio
             return;
         }
 
-        var platformSuffix = GetPlatformSuffix();
+        var platformSuffix = await GetPlatformSuffix(cancellationToken);
         if (string.IsNullOrWhiteSpace(platformSuffix))
         {
             _flowCtlLogger.WriteError(Resources.Commands_Init_UnsupportedPlatform);
@@ -170,7 +170,8 @@ private async Task InitializeDockerAsync(InitCommandOptions options, Cancellatio
             ContainerPort = EngineContainerPort,
             HostDataPath = hostDataPath,
             ContainerDataPath = containerDataPath,
-            Detached = true
+            Detached = true,
+            AdditionalArguments = " --start"
         };
 
         _flowCtlLogger.Write(string.Format(Resources.Commands_Init_CreatingDockerContainer, containerName, port));
@@ -353,14 +354,12 @@ private async Task<string> ResolveFlowSynxImageVersion(string? requestedVersion,
         return NormalizeDockerVersion(version);
     }
 
-    private string? GetPlatformSuffix()
+    private async Task<string?> GetPlatformSuffix(CancellationToken cancellationToken)
     {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        var mode = await _dockerService.GetDockerModeAsync(cancellationToken);
+        if (mode == "Windows")
             return "windows-ltsc2022-amd64";
 
-        if (RuntimeInformation.ProcessArchitecture != Architecture.X64)
-            return null;
-
         return "linux-amd64";
     }