squared 0.5.12 → 0.6.0

data/lib/squared/workspace/project/docker.rb

@@ -20,10 +20,11 @@ module Squared
                        sbom=q].freeze
           }.freeze,
           compose: {
-            common: %w[all-resources compatibility dry-run ansi|b env-file=p f|file=p parallel=n profile=b progress=b
+            common: %w[all-resources ansi|b compatibility dry-run env-file=p f|file=p parallel=n profile=b progress=b
                        project-directory=p p|project-name=e].freeze,
             build: %w[check no-cache print pull push with-dependencies q|quiet build-arg=qq builder=b m|memory=b
                       provenance=q sbom=q ssh=qq].freeze,
+            create: %w[build force-recreate no-build no-recreate quiet-pull remove-orphans y|yes pull=b scale=i].freeze,
             exec: %w[d|detach privileged e|env=qq index=i T|no-TTY=b? user=e w|workdir=q].freeze,
             run: %w[build d|detach no-deps q|quiet quiet-build quiet-pull remove-orphans rm P|service-ports use-aliases
                     cap-add=b cap-drop=b entrypoint=q e|env=qq env-from-file=p i|interactive=b? l|label=q name=b
@@ -57,13 +58,13 @@ module Squared
             commit: %w[a|author=q c|change=q m|message=q pause=b?].freeze,
             inspect: %w[s|size f|format=q type=b].freeze,
             start: %w[a|attach i|interactive detach-keys=q].freeze,
-            stop: %w[s|signal=b t|time=i t|timeout=i].freeze,
-            restart: %w[s|signal=b t|time=i t|timeout=i].freeze,
+            stop: %w[s|signal=b t|timeout=i].freeze,
+            restart: %w[s|signal=b t|timeout=i].freeze,
             kill: %w[s|signal=b].freeze,
             stats: %w[a|all no-stream no-trunc format|q].freeze
           }.freeze,
           image: {
-            list: %w[a|all q|quiet digests no-trunc tree f|filter=q format=q].freeze,
+            ls: %w[a|all digests no-trunc q|quiet tree f|filter=q format=q].freeze,
             push: %w[a|all-tags disable-content-trust=b? platform=b q|quiet].freeze,
             rm: %w[f|force no-prune platform=b].freeze,
             save: %w[o|output=p platform=b].freeze
@@ -80,6 +81,15 @@ module Squared
             volume: %w[volume-subpath volume-nocopy volume-opt].freeze,
             tmpfs: %w[tmpfs-size tmpfs-mode].freeze,
             image: %w[image-path].freeze
+          }.freeze,
+          ls: {
+            compose: %w[Name Image Command Service RunningFor Status Ports CreatedAt ExitCode Health ID Labels
+                        LocalVolumes Mounts Names Networks Project Publishers Size State].freeze,
+            container: %w[ID Image Command RunningFor Status Ports Names CreatedAt Labels LocalVolumes Mounts Networks
+                          Platform Size State].freeze,
+            image: %w[Repository Tag ID Containers CreatedSince Size CreatedAt Digest SharedSize UniqueSize
+                      VirtualSize].freeze,
+            network: %w[ID Name Driver Scope CreatedAt IPv4 IPv6 Internal Labels].freeze
           }.freeze
         }.freeze
         private_constant :COMPOSEFILE, :BAKEFILE, :OPT_DOCKER, :VAL_DOCKER
@@ -98,12 +108,13 @@ module Squared
 
         subtasks({
           'build' => %i[tag context].freeze,
-          'compose' => %i[build run exec up down].freeze,
+          'compose' => %i[build create run exec up down service].freeze,
           'bake' => %i[build check].freeze,
-          'image' => %i[list rm push tag save].freeze,
+          'image' => %i[ls rm push tag save].freeze,
           'container' => %i[run create exec update commit inspect diff start stop restart pause unpause top stats kill
                             rm].freeze,
-          'network' => %i[connect disconnect].freeze
+          'network' => %i[connect disconnect].freeze,
+          'ls' => nil
         })
 
         attr_reader :context
@@ -136,114 +147,168 @@ module Squared
             Docker.subtasks do |action, flags|
               next if task_pass?(action)
 
-              namespace action do
-                flags.each do |flag|
-                  case action
-                  when 'build'
-                    case flag
-                    when :tag, :context
+              if flags.nil?
+                case action
+                when 'ls'
+                  format_desc(action, nil, VAL_DOCKER[:ls].keys, after: 'a/ll?,s/tandard?,range*', arg: nil)
+                  task action, [:command] do |_, args|
+                    command = param_guard(action, 'command', args: args, key: :command)
+                    args = args.extras
+                    a = args.delete('a') || args.delete('all')
+                    ls = case command
+                         when 'network'
+                           a = nil
+                           'ls'
+                         when 'image', 'container'
+                           'ls'
+                         when 'compose'
+                           'ps'
+                         else
+                           raise_error ArgumentError, 'unrecognized command', hint: command
+                         end
+                    data = VAL_DOCKER[:ls][command.to_sym]
+                    if args.delete('s') || args.delete('standard')
+                      cols = data.first(data.index('CreatedAt'))
+                    else
+                      cols = []
+                      args.each do |val|
+                        if val =~ /^(\d+)$/
+                          cols << data[$1.to_i.pred]
+                        elsif val =~ /^(\d+)(-|\.{2,3})(\d+)$/
+                          j = $1.to_i.pred
+                          k = $3.to_i - ($2 == '..' ? 2 : 1)
+                          cols.concat(data[j..k]) if k > j
+                        end
+                      end
+                      if cols.empty?
+                        cols = choice_index('Select a column', data, multiple: true, force: true, attempts: 1)
+                      end
+                    end
+                    cmd = docker_output(command, ls, a && '-a')
+                    cmd << quote_option('format', "table #{cols.map! { |val| "{{.#{val}}}" }.join("\t")}")
+                    run(cmd, banner: false, from: :ls)
+                  end
+                end
+              else
+                namespace action do
+                  flags.each do |flag|
+                    case action
+                    when 'build'
                       format_desc(action, flag, 'opts*', before: flag == :tag ? 'name' : 'dir')
                       task flag, [flag] do |_, args|
                         param = param_guard(action, flag, args: args, key: flag)
                         buildx(:build, args.extras, "#{flag}": param)
                       end
-                    end
-                  when 'bake'
-                    break unless bake?
-
-                    case flag
-                    when :build
-                      format_desc action, flag, 'opts*,target*,context?|:'
-                      task flag do |_, args|
-                        args = args.to_a
-                        if args.first == ':'
-                          choice_command :bake
-                        else
-                          buildx :bake, args
+                    when 'bake'
+                      break unless bake?
+
+                      case flag
+                      when :build
+                        format_desc action, flag, 'opts*,target*,context?|:'
+                        task flag do |_, args|
+                          args = args.to_a
+                          if args.first == ':'
+                            choice_command :bake
+                          else
+                            buildx :bake, args
+                          end
                         end
-                      end
-                    when :check
-                      format_desc action, flag, 'target'
-                      task flag, [:target] do |_, args|
-                        target = param_guard(action, flag, args: args, key: :target)
-                        buildx :bake, ['allow=fs.read=*', 'call=check', target]
-                      end
-                    end
-                  when 'compose'
-                    break unless compose?
-
-                    case flag
-                    when :build, :up, :down
-                      format_desc action, flag, 'opts*,service*|:'
-                      task flag do |_, args|
-                        compose! flag, args.to_a
-                      end
-                    when :exec, :run
-                      format_desc action, flag, "service|:,command#{flag == :exec ? '' : '?'}|::,args*,opts*"
-                      task flag, [:service] do |_, args|
-                        service = param_guard(action, flag, args: args, key: :service)
-                        compose!(flag, args.extras, service: service)
-                      end
-                    end
-                  when 'container'
-                    case flag
-                    when :exec, :commit
-                      format_desc(action, flag, flag == :exec ? 'id/name,opts*,args+|:' : 'id/name,tag?,opts*')
-                      task flag, [:id] do |_, args|
-                        if flag == :exec && !args.id
-                          choice_command flag
-                        else
-                          id = param_guard(action, flag, args: args, key: :id)
-                          container(flag, args.extras, id: id)
+                      when :check
+                        format_desc action, flag, 'target'
+                        task flag, [:target] do |_, args|
+                          target = param_guard(action, flag, args: args, key: :target)
+                          buildx :bake, ['allow=fs.read=*', 'call=check', target]
                         end
                       end
-                    when :run, :create
-                      format_desc action, flag, 'image,opts*,args*|:'
-                      task flag, [:image] do |_, args|
-                        if args.image
-                          container(flag, args.extras, id: args.image)
-                        else
-                          choice_command flag
+                    when 'compose'
+                      break unless compose?
+
+                      case flag
+                      when :exec, :run
+                        format_desc action, flag, "service|:,command#{flag == :exec ? '' : '?'}|::,args*,opts*"
+                        task flag, [:service] do |_, args|
+                          service = param_guard(action, flag, args: args, key: :service)
+                          compose!(flag, args.extras, service: service)
+                        end
+                      when :service
+                        cmds = %w[down kill pause restart rm start stop top unpause watch].freeze
+                        format_desc(action, flag, cmds, arg: nil, after: 'name+|:')
+                        task flag, [:command] do |_, args|
+                          command = param_guard(action, flag, args: args, key: :command)
+                          raise_error ArgumentError, 'unrecognized command', hint: command unless cmds.include?(command)
+                          service = args.extras
+                          if service.first == ':'
+                            choice_command flag, command
+                          else
+                            compose!(flag, [command], service: service.empty? || service)
+                          end
+                        end
+                      else
+                        format_desc action, flag, 'opts*,service*|:'
+                        task flag do |_, args|
+                          compose!(flag, args.to_a, multiple: true)
                         end
                       end
-                    else
-                      format_desc action, flag, "opts*,id/name#{flag == :update ? '+' : '*'}"
-                      task flag do |_, args|
-                        container flag, args.to_a
+                    when 'container'
+                      case flag
+                      when :exec, :commit
+                        format_desc(action, flag, flag == :exec ? 'id/name,opts*,args+|:' : 'id/name,tag?,opts*')
+                        task flag, [:id] do |_, args|
+                          if flag == :exec && !args.id
+                            choice_command flag
+                          else
+                            id = param_guard(action, flag, args: args, key: :id)
+                            container(flag, args.extras, id: id)
+                          end
+                        end
+                      when :run, :create
+                        format_desc action, flag, 'image,opts*,args*|:'
+                        task flag, [:image] do |_, args|
+                          if args.image
+                            container(flag, args.extras, id: args.image)
+                          else
+                            choice_command flag
+                          end
+                        end
+                      else
+                        format_desc action, flag, "opts*,id/name#{flag == :update ? '+' : '*'}"
+                        task flag do |_, args|
+                          container flag, args.to_a
+                        end
                       end
-                    end
-                  when 'image'
-                    case flag
-                    when :push
-                      format_desc action, flag, 'tag,registry/username?,opts*'
-                      task flag, [:tag] do |_, args|
-                        id = param_guard(action, flag, args: args, key: :tag)
-                        image(flag, args.extras, id: id)
+                    when 'image'
+                      case flag
+                      when :push
+                        format_desc action, flag, 'tag,registry/username?,opts*'
+                        task flag, [:tag] do |_, args|
+                          id = param_guard(action, flag, args: args, key: :tag)
+                          image(flag, args.extras, id: id)
+                        end
+                      else
+                        format_desc(action, flag, case flag
+                                                  when :rm, :save then 'id*,opts*'
+                                                  when :tag then 'version?'
+                                                  else 'opts*,args*'
+                                                  end)
+                        task flag do |_, args|
+                          args = args.to_a
+                          if !args.empty? || flag == :ls
+                            image flag, args
+                          else
+                            choice_command flag
+                          end
+                        end
                       end
-                    else
-                      format_desc(action, flag, case flag
-                                                when :rm, :save then 'id*,opts*'
-                                                when :tag then 'version?'
-                                                else 'opts*,args*'
-                                                end)
-                      task flag do |_, args|
-                        args = args.to_a
-                        if args.empty? && flag != :list
-                          choice_command flag
+                    when 'network'
+                      format_desc action, flag, 'target,opts*'
+                      task flag, [:target] do |_, args|
+                        if args.target
+                          network(flag, args.extras, target: args.target)
                         else
-                          image flag, args
+                          choice_command flag
                         end
                       end
                     end
-                  when 'network'
-                    format_desc action, flag, 'target,opts*'
-                    task flag, [:target] do |_, args|
-                      if args.target
-                        network(flag, args.extras, target: args.target)
-                      else
-                        choice_command flag
-                      end
-                    end
                   end
                 end
               end
@@ -260,7 +325,7 @@ module Squared
         end
 
         def compose(opts, flags = nil, script: false, args: nil, from: :run, **)
-          return opts if script == false
+          return opts unless script
 
           ret = docker_session
           if from == :run
@@ -286,10 +351,10 @@ module Squared
           when Enumerable
             ret.merge(opts.to_a)
           end
-          [args, flags].each_with_index do |target, index|
-            if (data = append_any(target, target: []))
-              ret.merge(data.map { |arg| index == 0 ? fill_option(arg) : quote_option('build-arg', arg) })
-            end
+          [args, flags].each_with_index do |item, i|
+            next unless item && (data = append_any(item, target: []))
+
+            ret.merge(data.map! { |arg| i == 0 ? fill_option(arg) : quote_option('build-arg', arg) })
           end
           case from
           when :run
@@ -312,8 +377,8 @@ module Squared
             end
             append_context
           when :bake, :compose
-            option(from == :bake ? 'target' : 'service', ignore: false) do |a|
-              ret.merge(split_escape(a).map! { |b| shell_quote(b) })
+            option(from == :bake ? 'target' : 'service', ignore: false) do |val|
+              ret.merge(split_escape(val).map! { |s| shell_quote(s) })
             end
           end
           ret
@@ -321,9 +386,11 @@ module Squared
 
         def buildx(flag, opts = [], tag: nil, context: nil)
           cmd, opts = docker_session('buildx', opts: opts)
-          op = OptionPartition.new(opts, OPT_DOCKER[:buildx][:common], cmd, project: self)
-          op << flag
-          op.parse(OPT_DOCKER[:buildx][flag == :bake ? :bake : :build] + OPT_DOCKER[:buildx][:shared])
+          op = OPT_DOCKER[:buildx].yield_self do |data|
+            OptionPartition.new(opts, data[:common], cmd, project: self)
+                           .append(flag, quote: false)
+                           .parse(data[flag == :bake ? :bake : :build] + data[:shared])
+          end
           case flag
           when :build, :context
             append_tag(tag || option('tag', ignore: false) || self.tag)
@@ -347,46 +414,56 @@ module Squared
           run(from: :"buildx:#{flag}")
         end
 
-        def compose!(flag, opts = [], service: nil)
-          cmd, opts = docker_session('compose', opts: opts)
-          op = OptionPartition.new(opts, OPT_DOCKER[:compose][:common], cmd, project: self)
-          append_file filetype unless op.arg?('f', 'file')
-          op << flag
-          op.parse(OPT_DOCKER[:compose].fetch(flag, []))
-          multiple = case flag
-                     when :build, :up, :down then true
-                     else false
-                     end
-          if op.remove(':') || service == ':'
-            keys = Set.new
-            read_composefile('services', target: op.values_of('f', 'file')) { |data| keys.merge(data.keys) }
-            service = unless keys.empty?
-                        choice_index('Add services', keys, multiple: multiple, force: !multiple,
-                                                           attempts: multiple ? 1 : 5)
-                      end
-          end
-          if multiple
-            op.concat(service) if service
-            op.append(delim: true, escape: true, strip: /^:/)
+        def compose!(flag, opts = [], service: nil, multiple: false)
+          from = :"compose:#{flag}"
+          if flag == :service
+            command = opts.first
+            if service == true
+              cmd, status = filter_ps command, from
+              lines = IO.popen(cmd.temp('--services')).map(&:strip).reject(&:empty?)
+              return list_empty(hint: status) if lines.empty?
+
+              service = choice_index('Choose a service', lines, multiple: true, force: true, attempts: 1)
+            end
+            docker_session('compose', command, '--', *service)
           else
-            raise_error('no services were found', hint: flag) unless service
-            append_command(flag, service, op.extras, prompt: '::')
+            cmd, opts = docker_session('compose', opts: opts)
+            op = OptionPartition.new(opts, OPT_DOCKER[:compose][:common], cmd, project: self)
+            append_file filetype unless op.arg?('f', 'file')
+            op << flag
+            op.parse(OPT_DOCKER[:compose].fetch(flag, []))
+            if op.remove(':') || service == ':'
+              keys = Set.new
+              read_composefile('services', target: op.values_of('f', 'file')) { |data| keys.merge(data.keys) }
+              service = unless keys.empty?
+                          choice_index('Add services', keys, multiple: multiple, force: !multiple,
+                                                             attempts: multiple ? 1 : 3)
+                        end
+            end
+            if multiple
+              op.concat(service) if service
+              op.append(delim: true, escape: true, strip: /^:/)
+            else
+              raise_error ArgumentError, 'no service was selected', hint: flag unless service
+              append_command(flag, service, op.extras, prompt: '::')
+            end
           end
-          run(from: :"compose:#{flag}")
+          run(from: from)
         end
 
         def container(flag, opts = [], id: nil)
           cmd, opts = docker_session('container', flag, opts: opts)
           rc = flag == :run || flag == :create
-          list = OPT_DOCKER[:container].fetch(flag, [])
-          list += OPT_DOCKER[:container][:create] if flag == :run
-          list += OPT_DOCKER[:container][:update] if rc
-          op = OptionPartition.new(opts, list, cmd, project: self, args: rc || flag == :exec)
+          op = OPT_DOCKER[:container].yield_self do |data|
+            list = data.fetch(flag, [])
+            list += data[:create] if flag == :run
+            list += data[:update] if rc
+            OptionPartition.new(opts, list, cmd, project: self, args: rc || flag == :exec)
+          end
           from = :"container:#{flag}"
           case flag
           when :run, :create, :exec
             if rc && !op.arg?('mount')
-              run = VAL_DOCKER[:run]
               all = collect_hash VAL_DOCKER[:run]
               delim = Regexp.new(",\\s*(?=#{all.join('|')})")
               Array(@mounts).each do |val|
@@ -399,11 +476,11 @@ module Squared
                     when 'bind', 'volume', 'image', 'tmpfs'
                       type = v
                     else
-                      raise_error("unknown type: #{v}", hint: flag)
+                      raise_error TypeError, "unknown: #{v}", hint: flag
                     end
                   elsif all.include?(k)
                     unless type
-                      run.each_pair do |key, val|
+                      VAL_DOCKER[:run].each_pair do |key, val|
                         next unless val.include?(k)
 
                         type = key.to_s unless key == :common
@@ -423,18 +500,18 @@ module Squared
                     log_message(Logger::INFO, 'unrecognized option', subject: from, hint: k)
                   end
                 end
-                raise_error('missing type', hint: flag) unless type
+                raise_error TypeError, 'none specified', hint: flag unless type
                 cmd << "--mount type=#{type},#{args.join(',')}"
               end
             end
             append_command(flag, id || tagmain, op.extras)
           when :update
-            raise_error('missing container', hint: flag) if op.empty?
+            raise_error ArgumentError, 'missing container', hint: flag if op.empty?
             op.append(escape: true, strip: /^:/)
           when :commit
             latest = op.shift || tagmain
             cmd << id << latest
-            raise_error("unknown args: #{op.join(', ')}", hint: flag) unless op.empty?
+            raise_error ArgumentError, "unrecognized args: #{op.join(', ')}", hint: flag unless op.empty?
             return unless confirm_command(cmd.to_s, title: from, target: id, as: latest)
 
             registry = option('registry') || @registry
@@ -453,38 +530,12 @@ module Squared
             return image(:push, opts, id: latest, registry: registry)
           else
             if op.empty?
-              status = []
-              no = true
-              case flag
-              when :inspect, :diff
-                no = false
-              when :start
-                status = %w[created exited]
-                no = false
-              when :stop, :pause
-                status = %w[running restarting]
-              when :restart
-                status = %w[running paused exited]
-              when :unpause
-                status << 'paused'
-                no = false
-              when :top, :stats
-                status << 'running'
-                cmd << '--no-stream' if flag == :stats
-                no = false
-              when :kill
-                status = %w[running restarting paused]
-              when :rm
-                status = %w[created exited dead]
-              end
-              ps = docker_output('ps -a', *status.map { |s| quote_option('filter', "status=#{s}") })
-              list_image(flag, ps, no: no, hint: "status: #{status.join(', ')}", from: from) do |img|
-                run(cmd.temp(img), from: from)
-              end
+              ps, status, no = filter_ps flag, from
+              cmd << '--no-stream' if flag == :stats
+              list_image(flag, ps, no: no, hint: status, from: from) { |img| run(cmd.temp(img), from: from) }
               return
-            else
-              op.append(escape: true, strip: /^:/)
             end
+            op.append(escape: true, strip: /^:/)
           end
           run(from: from)
         end
@@ -492,16 +543,21 @@ module Squared
         def image(flag, opts = [], sync: true, id: nil, registry: nil)
           cmd, opts = docker_session('image', flag, opts: opts)
           op = OptionPartition.new(opts, OPT_DOCKER[:image].fetch(flag, []), cmd, project: self)
-          exception = @exception
+          exception = self.exception
           banner = true
           from = :"image:#{flag}"
           case flag
-          when :list
+          when :ls
             if opts.size == op.size
               index = 0
               name = nil
-              opts.reverse_each { |opt| break opts.delete(opt) if (name = opt[/^name=["']?(.+?)["']?$/, 1]) }
-              list_image(:run, cmd << '-a', from: from) do |val|
+              opts.reverse_each do |opt|
+                if (name = opt[/^name=["']?(.+?)["']?$/, 1])
+                  opts.delete(opt)
+                  break
+                end
+              end
+              list_image(:run, from: from) do |val|
                 container(:run, if name
                                   opts.dup << "name=#{index == 0 ? name : "#{name}-#{index}"}"
                                 else
@@ -510,19 +566,12 @@ module Squared
                 index += 1
               end
               return
-            else
-              op.clear
             end
+            op.clear
           when :rm
-            if id
-              op << id
-              if option('y')
-                exception = false
-                banner = false
-              end
-            else
+            unless id
               if op.empty?
-                list_image(:rm, docker_output('image ls -a'), from: from) do |val|
+                list_image(:rm, from: from) do |val|
                   image(:rm, opts, sync: sync, id: val)
                 end
               else
@@ -530,8 +579,13 @@ module Squared
               end
               return
             end
+            op << id
+            if option('y')
+              exception = false
+              banner = false
+            end
           when :tag, :save
-            list_image(flag, docker_output('image ls -a'), from: from) do |val|
+            list_image(flag, from: from) do |val|
               op << val
               if flag == :tag
                 op << tagname("#{project}:#{op.first}")
@@ -541,8 +595,14 @@ module Squared
           when :push
             id ||= option('tag', ignore: false) || tagmain
             registry ||= op.shift || option('registry') || @registry
-            raise_error(id ? "unknown args: #{op.join(', ')}" : 'no id/tag given', hint: flag) unless id && op.empty?
-            raise_error('username/registry not provided', hint: flag) unless registry
+            unless id && op.empty?
+              if id
+                raise_error ArgumentError, "unrecognized args: #{op.join(', ')}", hint: flag
+              else
+                raise_error 'no id/tag', hint: flag
+              end
+            end
+            raise_error ArgumentError, 'username/registry not specified', hint: flag unless registry
             registry.chomp!('/')
             uri = shell_quote "#{registry}/#{id}"
             op << uri
@@ -554,17 +614,18 @@ module Squared
             exception = true
             banner = false
           end
-          ret = run(cmd, sync: sync, exception: exception, banner: banner, from: from)
-          print_success if success?(ret, flag == :tag || flag == :save)
+          run(cmd, sync: sync, exception: exception, banner: banner, from: from).tap do |ret|
+            success?(ret, flag == :tag || flag == :save)
+          end
         end
 
         def network(flag, opts = [], target: nil)
           cmd, opts = docker_session('network', flag, opts: opts)
-          op = OptionPartition.new(opts, OPT_DOCKER[:network].fetch(flag, []), cmd, project: self)
-          op.clear
+          OptionPartition.new(opts, OPT_DOCKER[:network].fetch(flag, []), cmd, project: self)
+                         .clear
           from = :"network:#{flag}"
           list_image(flag, docker_output('ps -a'), from: from) do |img|
-            print_success if success?(run(cmd.temp(target, img), from: from))
+            success?(run(cmd.temp(target, img), from: from))
           end
         end
 
@@ -591,10 +652,10 @@ module Squared
         def dockerfile(val = nil)
           if val
             @file = if val.is_a?(Array)
-                      val = val.select { |file| basepath(file).exist? }
+                      val = val.select { |file| exist?(file) }
                       val.size > 1 ? val : val.first
                     elsif val == true
-                      DIR_DOCKER.find { |file| basepath(file).exist? }
+                      DIR_DOCKER.find { |file| exist?(file) }
                     elsif val != 'Dockerfile'
                       val
                     end
@@ -623,8 +684,7 @@ module Squared
           return session('docker', *cmd) unless opts
 
           op = OptionPartition.new(opts, OPT_DOCKER[:common], project: self)
-          ret = session('docker', *op.to_a, *cmd)
-          [ret, op.extras]
+          [session('docker', *op.to_a, *cmd), op.extras]
         end
 
         def docker_output(*cmd, **kwargs)
@@ -634,8 +694,8 @@ module Squared
         def append_command(flag, val, list, target: @session, prompt: ':')
           if list.delete(prompt)
             list << readline('Enter command [args]', force: flag == :exec)
-          elsif (args = env('DOCKER_ARGS'))
-            list << args
+          else
+            env('DOCKER_ARGS') { |args| list << args }
           end
           case flag
           when :run
@@ -643,7 +703,7 @@ module Squared
               target << basic_option('name', dnsname("#{name}_%s" % rand_s(6)))
             end
           when :exec
-            raise_error('no command args', hint: flag) if list.empty?
+            raise_error ArgumentError, 'nothing to execute', hint: flag if list.empty?
           end
           target << val << list.shift
           target << list.join(' && ') unless list.empty?
@@ -695,17 +755,45 @@ module Squared
           end
         end
 
-        def list_image(flag, cmd, hint: nil, from: nil, no: true)
+        def filter_ps(flag, from = :'container:ps')
+          no = false
+          status = case flag.to_sym
+                   when :start
+                     %w[created exited]
+                   when :stop, :pause
+                     no = true
+                     %w[running restarting]
+                   when :restart
+                     no = true
+                     %w[running paused exited]
+                   when :unpause
+                     %w[paused]
+                   when :top, :stats, :watch
+                     %w[running]
+                   when :kill
+                     no = true
+                     %w[running paused restarting]
+                   when :rm
+                     no = true
+                     %w[created exited dead]
+                   else
+                     []
+                   end
+          cmd = docker_output("#{from.to_s.split(':').first} ps -a",
+                              *status.map { |s| quote_option('filter', "status=#{s}") })
+          [cmd, status, no]
+        end
+
+        def list_image(flag, cmd = docker_output('image ls -a'), hint: nil, from: nil, no: true)
           pwd_set do
-            found = false
-            index = 0
+            index = 1
             all = option('all', prefix: 'docker')
             y = from == :'image:rm' && option('y', prefix: 'docker')
             pat = /\b(?:#{dnsname(name)}|#{tagname(project)}|#{tagmain.split(':', 2).first})\b/
-            IO.popen(session_done(cmd << '--format=json')).each do |line|
+            IO.popen(cmd.temp('--format=json')).each do |line|
               data = JSON.parse(line)
               id = data['ID']
-              rt = [data['Repository'], data['Tag']].reject { |val| val == '<none>' }.join(':')
+              rt = [data['Repository'], data['Tag']].reject { |val| val.to_s.empty? || val == '<none>' }.join(':')
               rt = nil if rt.empty?
               aa = data['Names'] || (if rt && data['Repository']
                                        dd = true
@@ -717,16 +805,16 @@ module Squared
               next unless all || ee.match?(pat) || aa.match?(pat)
 
               unless y
-                bb = index.succ.to_s
-                cc = bb.size + 1
+                bb = index.to_s
+                cc = bb.size.succ
                 a = sub_style(ee, styles: theme[:inline])
-                b = "Execute #{sub_style(flag, styles: theme[:active])} on #{a}#{ee == id ? '' : " (#{id})"}"
+                b = "Execute #{sub_style(flag, styles: theme[:active])} on #{a.subhint(ee == id ? nil : id)}"
                 e = time_format(time_since(data['CreatedAt']), pass: ['ms'])
                 f = sub_style(ARG[:BORDER][0], styles: theme[:inline])
-                g = ' ' * (cc + 1)
+                g = ' ' * cc.succ
                 h = "#{sub_style(bb.rjust(cc), styles: theme[:current])} #{f} "
-                puts unless index == 0
-                puts "#{h + sub_style(aa, styles: theme[:subject])} (created #{e} ago)"
+                puts unless index == 1
+                puts (h + sub_style(aa, styles: theme[:subject])).subhint("created #{e} ago")
                 cols = %w[Tag Status Ports]
                 cols << case flag
                         when :connect, :disconnect
@@ -741,89 +829,104 @@ module Squared
                 end
                 w = 9 + flag.to_s.size + 4 + ee.size
                 puts g + sub_style(ARG[:BORDER][6] + (ARG[:BORDER][1] * w), styles: theme[:inline])
-                found = true
                 index += 1
-                next unless confirm("#{h + b}?", no ? 'N' : 'Y', timeout: 60)
+                next unless confirm("#{h + b}?", no ? 'N' : 'Y')
 
                 puts if printfirst?
               end
               yield id
             end
-            puts log_message(Logger::INFO, 'none detected', subject: name, hint: hint || from) if !found && !y
+            list_empty(hint: hint || from) if index == 1 && !y
           end
         rescue StandardError => e
           on_error e, from
         end
 
+        def list_empty(subject: name, hint: nil, **kwargs)
+          hint = "status: #{hint.join(', ')}" if hint.is_a?(Array)
+          puts log_message(Logger::INFO, 'none detected', subject: subject, hint: hint, **kwargs)
+        end
+
         def confirm_command(*args, title: nil, target: nil, as: nil)
           return false unless title && target
 
           puts unless printfirst?
           t = title.to_s.split(':')
           emphasize(args, title: message(t.first.upcase, *t.drop(1)), border: borderstyle, sub: [
-            { pat: /\A(\w+(?: => \w+)+)(.*)\z/, styles: theme[:header] },
-            { pat: /\A(.+)\z/, styles: theme[:caution] }
+            opt_style(theme[:header], /\A(\w+(?: => \w+)+)(.*)\z/),
+            opt_style(theme[:caution], /\A(.+)\z/)
           ])
           printsucc
           a = t.last.capitalize
           b = sub_style(target, styles: theme[:subject])
           c = as && sub_style(as, styles: theme[:inline])
-          confirm("#{a} #{b}#{c ? " as #{c}" : ''}?", 'N', timeout: 60)
-        end
-
-        def choice_command(flag)
-          msg, cmd, index = case flag
-                            when :exec
-                              ['Choose a container', 'ps -a', 0]
-                            when :bake
-                              ['Choose a target', 'buildx bake --list=type=targets', 0]
-                            when :connect, :disconnect
-                              ['Choose a network', 'network ls', 0]
-                            else
-                              ['Choose an image', 'images -a', 2]
-                            end
+          confirm "#{a} #{b}#{c ? " as #{c}" : ''}?", 'N'
+        end
+
+        def choice_command(flag, *action)
+          msg, cmd = case flag
+                     when :exec
+                       ['Choose a container', 'ps -a']
+                     when :bake
+                       ['Choose a target', 'buildx bake --list=type=targets']
+                     when :connect, :disconnect
+                       ['Choose a network', 'network ls']
+                     when :service
+                       ['Choose a service',
+                        'compose ps -a ' \
+                        "--format='table {{.Service}}\t{{.Name}}\t{{.Image}}\t{{.Command}}\t{{.Status}}\t{{.Ports}}'"]
+                     else
+                       ['Choose an image',
+                        'images -a ' \
+                        "--format='table {{.ID}}\t{{.Repository}}\t{{.Tag}}\t{{.CreatedSince}}\t{{.Size}}'"]
+                     end
           lines = `#{docker_output(cmd)}`.lines
           header = lines.shift
           if lines.empty?
-            puts log_message(Logger::INFO, 'none found', subject: name, hint: "docker #{cmd}")
-          else
-            puts " #  #{header}"
-            multiple = false
-            parse = ->(val) { val.split(/\s+/)[index] }
-            ctx = flag.to_s
-            case flag
-            when :run, :exec
-              values = [['Options', flag == :run], ['Arguments', flag == :exec]]
-            when :rm, :bake
-              values = ['Options']
-              multiple = true
-              ctx = flag == :rm ? 'image rm' : "buildx bake -f #{shell_quote(dockerfile)}"
-            when :save
-              values = [['Output', true], 'Platform']
-              multiple = true
-            when :connect, :disconnect
-              values = ['Options', ['Container', true]]
-              ctx = "network #{flag}"
-            end
-            out, opts, args = choice_index(msg, lines, multiple: multiple, values: values)
-            cmd = docker_output ctx
-            case flag
-            when :tag
-              args = tagjoin @registry, tag
-            when :save
-              opts = "#{opts}.tar" unless opts.end_with?('.tar')
-              cmd << quote_option('output', File.expand_path(opts))
-              if args
-                cmd << basic_option('platform', args)
-                args = nil
-              end
-            else
-              cmd << opts << '--'
+            puts log_message(Logger::INFO, 'none found', subject: name,
+                                                         hint: "docker #{cmd.split(' ', 3)[0...2].join(' ')}")
+            return
+          end
+          puts " #  #{header}"
+          multiple = false
+          parse = ->(val) { val.split(/\s+/)[0] }
+          ctx = flag.to_s
+          case flag
+          when :run, :exec
+            values = [['Options', flag == :run], ['Arguments', flag == :exec]]
+          when :rm, :bake
+            values = ['Options']
+            multiple = true
+            ctx = flag == :rm ? 'image rm' : "buildx bake -f #{shell_quote(dockerfile)}"
+          when :save
+            values = [['Output', true], 'Platform']
+            multiple = true
+          when :service
+            values = []
+            multiple = true
+            ctx = 'compose'
+          when :connect, :disconnect
+            values = ['Options', ['Container', true]]
+            ctx = "network #{flag}"
+          end
+          out, opts, args = choice_index(msg, lines, multiple: multiple, values: values)
+          cmd = docker_output(ctx, *action)
+          case flag
+          when :tag
+            args = tagjoin @registry, tag
+          when :save
+            opts = "#{opts}.tar" unless opts.end_with?('.tar')
+            cmd << quote_option('output', File.expand_path(opts))
+            if args
+              cmd << basic_option('platform', args)
+              args = nil
             end
-            cmd.merge(Array(out).map! { |val| parse.call(val) })
-            cmd << args
-            print_success if success?(run(cmd), ctx.start_with?(/(?:network|tag|save)/))
+          else
+            cmd << opts << '--'
           end
+          cmd.merge(Array(out).map! { |val| parse.call(val) })
+          cmd << args
+          success?(run(cmd), ctx.start_with?(/(?:network|tag|save)/))
         end
 
         def filetype(val = dockerfile)
@@ -852,10 +955,9 @@ module Squared
 
         def tagname(val)
           val = val.split(':').map! { |s| charname(s.sub(/^\W+/, '')) }
-          val.join(':').yield_self do |s|
-            s = val.first if val.size > 1 && s.size > 128
-            s[0..127]
-          end
+          ret = val.join(':')
+          ret = val.first if val.size > 1 && ret.size > 128
+          ret[0..127]
         end
 
         def dnsname(val)