Bump DotNext.Threading and 2 others

src/CommandChainDetector.cs

@@ -0,0 +1,52 @@
+namespace port;
+
+/// <summary>
+/// Detects if the current command is part of a command chain by analyzing command execution context.
+/// This helps determine when to suppress intermediate output like listing current state.
+/// </summary>
+internal class CommandChainDetector : ICommandChainDetector
+{
+    private readonly Lazy<bool> _shouldDisplayOutput;
+
+    public CommandChainDetector()
+    {
+        _shouldDisplayOutput = new Lazy<bool>(DetectShouldDisplayOutput);
+    }
+
+    public bool ShouldDisplayOutput() => _shouldDisplayOutput.Value;
+
+    private static bool DetectShouldDisplayOutput()
+    {
+        try
+        {
+            // Get the current command being executed
+            var args = Environment.GetCommandLineArgs();
+            if (args.Length < 2)
+                return true;
+
+            var command = args[1].ToLowerInvariant();
+
+            // Commands that typically end chains and should show output by default
+            var finalCommands = new[] { "prune", "pr", "list", "ls" };
+
+            // Commands that are typically intermediate in chains
+            var intermediateCommands = new[] { "pull", "p", "run", "r" };
+
+            // Simple heuristic: if this is a command that typically ends chains, show output
+            // Otherwise, for intermediate commands, we suppress by default (conservative approach)
+            if (finalCommands.Contains(command))
+                return true;
+
+            if (intermediateCommands.Contains(command))
+                return false;
+
+            // For other commands (commit, reset, stop, remove, etc.), show output by default
+            return true;
+        }
+        catch
+        {
+            // If we can't determine the chain status, default to showing output
+            return true;
+        }
+    }
+}

src/Commands/Commit/CommitCliCommand.cs

@@ -14,83 +14,108 @@ internal class CommitCliCommand(
     IGetDigestsByIdQuery getDigestsByIdQuery,
     IGetContainersQuery getContainersQuery,
     IStopAndRemoveContainerCommand stopAndRemoveContainerCommand,
-    ListCliCommand listCliCommand)
-    : AsyncCommand<CommitSettings>
+    ConditionalListCliCommand conditionalListCliCommand
+) : AsyncCommand<CommitSettings>
 {
     public override async Task<int> ExecuteAsync(CommandContext context, CommitSettings settings)
     {
-        var container = await GetContainerAsync(settings) ??
-                        throw new InvalidOperationException("No running container found");
+        var container =
+            await GetContainerAsync(settings)
+            ?? throw new InvalidOperationException("No running container found");
 
-        await Spinner.StartAsync("Committing container", async ctx =>
-        {
-            string newTag;
-            string imageName;
-            string tagPrefix;
-            if (settings.Overwrite)
-            {
-                newTag = container.ImageTag ??
-                         throw new InvalidOperationException(
-                             "When using --overwrite, container must have an image tag");
-                imageName = container.ImageIdentifier;
-                tagPrefix = container.TagPrefix;
-            }
-            else
+        await Spinner.StartAsync(
+            "Committing container",
+            async ctx =>
             {
-                var tag = settings.Tag ?? $"{DateTime.Now:yyyyMMddhhmmss}";
-                (imageName, tagPrefix, newTag) = await GetNewTagAsync(container, tag);
-            }
-
-
-            ctx.Status = $"Looking for existing container named '{container.ContainerName}'";
-            var containerWithSameTag = await getContainersQuery
-                .QueryByContainerIdentifierAndTagAsync(container.ContainerIdentifier, newTag)
-                .ToListAsync();
-
-            ctx.Status = $"Creating image from running container '{container.ContainerName}'";
-            newTag = await createImageFromContainerCommand.ExecuteAsync(container, imageName, tagPrefix, newTag);
-
-            ctx.Status = $"Removing containers named '{container.ContainerName}'";
-            await Task.WhenAll(containerWithSameTag.Select(async container1 =>
-                await stopAndRemoveContainerCommand.ExecuteAsync(container1.Id)));
-
-            if (settings.Overwrite)
-            {
-                if (newTag == null)
-                    throw new InvalidOperationException("newTag is null");
-
-                if (container.ImageTag == null)
-                    throw new InvalidOperationException(
-                        "Switch argument not supported when creating image from untagged container");
-
-                ctx.Status = "Launching new image";
-                var id = await createContainerCommand.ExecuteAsync(container, tagPrefix, newTag);
-                await runContainerCommand.ExecuteAsync(id);
-            }
-            else if (settings.Switch)
-            {
-                if (newTag == null)
-                    throw new InvalidOperationException("newTag is null");
-
-                if (container.ImageTag == null)
-                    throw new InvalidOperationException(
-                        "Switch argument not supported when creating image from untagged container");
-
-                ctx.Status = $"Stopping running container '{container.ContainerName}'";
-                await stopContainerCommand.ExecuteAsync(container.Id);
-
-                ctx.Status = "Launching new image";
-                var id = await createContainerCommand.ExecuteAsync(container, tagPrefix, newTag);
-                await runContainerCommand.ExecuteAsync(id);
+                string newTag;
+                string imageName;
+                string tagPrefix;
+                if (settings.Overwrite)
+                {
+                    newTag =
+                        container.ImageTag
+                        ?? throw new InvalidOperationException(
+                            "When using --overwrite, container must have an image tag"
+                        );
+                    imageName = container.ImageIdentifier;
+                    tagPrefix = container.TagPrefix;
+                }
+                else
+                {
+                    var tag = settings.Tag ?? $"{DateTime.Now:yyyyMMddhhmmss}";
+                    (imageName, tagPrefix, newTag) = await GetNewTagAsync(container, tag);
+                }
+
+                ctx.Status = $"Looking for existing container named '{container.ContainerName}'";
+                var containerWithSameTag = await getContainersQuery
+                    .QueryByContainerIdentifierAndTagAsync(container.ContainerIdentifier, newTag)
+                    .ToListAsync();
+
+                ctx.Status = $"Creating image from running container '{container.ContainerName}'";
+                newTag = await createImageFromContainerCommand.ExecuteAsync(
+                    container,
+                    imageName,
+                    tagPrefix,
+                    newTag
+                );
+
+                ctx.Status = $"Removing containers named '{container.ContainerName}'";
+                await Task.WhenAll(
+                    containerWithSameTag.Select(async container1 =>
+                        await stopAndRemoveContainerCommand.ExecuteAsync(container1.Id)
+                    )
+                );
+
+                if (settings.Overwrite)
+                {
+                    if (newTag == null)
+                        throw new InvalidOperationException("newTag is null");
+
+                    if (container.ImageTag == null)
+                        throw new InvalidOperationException(
+                            "Switch argument not supported when creating image from untagged container"
+                        );
+
+                    ctx.Status = "Launching new image";
+                    var id = await createContainerCommand.ExecuteAsync(
+                        container,
+                        tagPrefix,
+                        newTag
+                    );
+                    await runContainerCommand.ExecuteAsync(id);
+                }
+                else if (settings.Switch)
+                {
+                    if (newTag == null)
+                        throw new InvalidOperationException("newTag is null");
+
+                    if (container.ImageTag == null)
+                        throw new InvalidOperationException(
+                            "Switch argument not supported when creating image from untagged container"
+                        );
+
+                    ctx.Status = $"Stopping running container '{container.ContainerName}'";
+                    await stopContainerCommand.ExecuteAsync(container.Id);
+
+                    ctx.Status = "Launching new image";
+                    var id = await createContainerCommand.ExecuteAsync(
+                        container,
+                        tagPrefix,
+                        newTag
+                    );
+                    await runContainerCommand.ExecuteAsync(id);
+                }
             }
-        });
+        );
 
-        await listCliCommand.ExecuteAsync();
+        await conditionalListCliCommand.ExecuteAsync();
         return 0;
     }
 
-    private async Task<(string imageName, string tagPrefix, string newTag)> GetNewTagAsync(Container container,
-        string tag)
+    private async Task<(string imageName, string tagPrefix, string newTag)> GetNewTagAsync(
+        Container container,
+        string tag
+    )
     {
         var image = await getImageQuery.QueryAsync(container.ImageIdentifier, container.ImageTag);
         string imageName;
@@ -101,7 +126,8 @@ await Task.WhenAll(containerWithSameTag.Select(async container1 =>
             var digest = digests?.SingleOrDefault();
             if (digest == null || !DigestHelper.TryGetImageNameAndId(digest, out var nameNameAndId))
                 throw new InvalidOperationException(
-                    $"Unable to determine image name from running container '{container.ContainerName}'");
+                    $"Unable to determine image name from running container '{container.ContainerName}'"
+                );
             imageName = nameNameAndId.imageName;
         }
         else
@@ -114,7 +140,8 @@ await Task.WhenAll(containerWithSameTag.Select(async container1 =>
 
         var tagPrefix = container.TagPrefix;
         var newTag = baseTag == null ? tag : $"{tagPrefix}{baseTag}-{tag}";
-        if (newTag.Contains('.')) throw new ArgumentException("only [a-zA-Z0-9][a-zA-Z0-9_-] are allowed");
+        if (newTag.Contains('.'))
+            throw new ArgumentException("only [a-zA-Z0-9][a-zA-Z0-9_-] are allowed");
         return (imageName, tagPrefix, newTag);
     }
 
@@ -129,4 +156,4 @@ await Task.WhenAll(containerWithSameTag.Select(async container1 =>
         var identifier = containerNamePrompt.GetIdentifierOfContainerFromUser(containers, "commit");
         return containers.SingleOrDefault(c => c.ContainerName == identifier);
     }
-}
+}

src/Commands/Commit/CommitSettings.cs

@@ -7,12 +7,12 @@ public class CommitSettings : CommandSettings, IContainerIdentifierSettings
     [CommandArgument(0, "[ContainerIdentifier]")]
     public string? ContainerIdentifier { get; set; }
 
-    [CommandOption("-t|--tag")] 
+    [CommandOption("-t|--tag")]
     public string? Tag { get; set; }
 
-    [CommandOption("-s|--switch")] 
+    [CommandOption("-s|--switch")]
     public bool Switch { get; set; }
 
-    [CommandOption("-o|--overwrite")] 
+    [CommandOption("-o|--overwrite")]
     public bool Overwrite { get; set; }
-}
+}

src/Commands/Commit/CreateImageFromContainerCommand.cs

@@ -3,27 +3,35 @@
 
 namespace port.Commands.Commit;
 
-internal class CreateImageFromContainerCommand(IDockerClient dockerClient) : ICreateImageFromContainerCommand
+internal class CreateImageFromContainerCommand(IDockerClient dockerClient)
+    : ICreateImageFromContainerCommand
 {
-    public async Task<string> ExecuteAsync(Container container, string imageName, string tagPrefix, string newTag)
+    public async Task<string> ExecuteAsync(
+        Container container,
+        string imageName,
+        string tagPrefix,
+        string newTag
+    )
     {
         var labels = new Dictionary<string, string>();
         var identifier = container.GetLabel(Constants.IdentifierLabel);
-        if (identifier is not null) labels.Add(Constants.IdentifierLabel, identifier);
+        if (identifier is not null)
+            labels.Add(Constants.IdentifierLabel, identifier);
         var baseTag = container.GetLabel(Constants.BaseTagLabel);
-        if (baseTag is not null) labels.Add(Constants.BaseTagLabel, baseTag);
+        if (baseTag is not null)
+            labels.Add(Constants.BaseTagLabel, baseTag);
         labels.Add(Constants.TagPrefix, tagPrefix);
-        if (baseTag == newTag) throw new InvalidOperationException("Can not overwrite base tags");
-        await dockerClient.Images.CommitContainerChangesAsync(new CommitContainerChangesParameters
-        {
-            ContainerID = container.Id,
-            RepositoryName = imageName,
-            Tag = newTag,
-            Config = new Docker.DotNet.Models.Config
+        if (baseTag == newTag)
+            throw new InvalidOperationException("Can not overwrite base tags");
+        await dockerClient.Images.CommitContainerChangesAsync(
+            new CommitContainerChangesParameters
             {
-                Labels = labels
+                ContainerID = container.Id,
+                RepositoryName = imageName,
+                Tag = newTag,
+                Config = new Docker.DotNet.Models.Config { Labels = labels },
             }
-        });
+        );
         return newTag;
     }
-}
+}

src/Commands/Commit/GetDigestsByIdQuery.cs

@@ -16,11 +16,10 @@ public GetDigestsByIdQuery(IDockerClient dockerClient)
     {
         var parameters = new ImagesListParameters
         {
-            Filters = new Dictionary<string, IDictionary<string, bool>>()
+            Filters = new Dictionary<string, IDictionary<string, bool>>(),
         };
         var imagesListResponses = await _dockerClient.Images.ListImagesAsync(parameters);
-        var imagesListResponse = imagesListResponses
-            .SingleOrDefault(e => e.ID == imageId);
+        var imagesListResponse = imagesListResponses.SingleOrDefault(e => e.ID == imageId);
         return imagesListResponse?.RepoDigests;
     }
-}
+}

src/Commands/Commit/ICreateImageFromContainerCommand.cs

@@ -2,5 +2,10 @@ namespace port.Commands.Commit;
 
 public interface ICreateImageFromContainerCommand
 {
-    Task<string> ExecuteAsync(Container container, string imageName, string tagPrefix, string newTag);
-}
+    Task<string> ExecuteAsync(
+        Container container,
+        string imageName,
+        string tagPrefix,
+        string newTag
+    );
+}

src/Commands/Commit/IGetDigestsByIdQuery.cs

@@ -3,4 +3,4 @@ namespace port.Commands.Commit;
 internal interface IGetDigestsByIdQuery
 {
     Task<IList<string>?> QueryAsync(string imageId);
-}
+}

src/Commands/Config/ConfigCliCommand.cs

@@ -22,5 +22,6 @@ public override int Execute(CommandContext context, ConfigSettings settings)
         return 0;
     }
 
-    private static string FormatAsLink(string caption, string url) => $"\u001B]8;;{url}\a{caption}\u001B]8;;\a";
-}
+    private static string FormatAsLink(string caption, string url) =>
+        $"\u001B]8;;{url}\a{caption}\u001B]8;;\a";
+}