dagger_ruby 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3236161fdcbdb34e426318363c0db9b1625fef0bfff6d83d021908ccaab26e69
-  data.tar.gz: d0510f01bd92c27f6f06ba2c2693007771ffb8d6fb8da663ef2aea8798bd09d6
+  metadata.gz: ebaf58b886e0c88802e55c2abb2f10676c4b00466dfd24fc69d6f38ead563e6a
+  data.tar.gz: ad9abb4ee776703af437e713bf3d61a99b80e0f0d9586dadda2a98c689faedf7
 SHA512:
-  metadata.gz: fb8c138bbf1c674ad47cffecb4d31c77348c83a4e83e6439f55240925587ba16035f53d21f49995d849807d6d1b9bd70edb0cabec3fe860c521efaade6307539
-  data.tar.gz: ad20b3fb027215a665fb58fbfde7ae125d791e7b596c449ac23f91e87e07e16de154d9775b19d070066855b26cb062e8d69ffe382f64d9c59feab438daa225d6
+  metadata.gz: ac82debf94e095271f87339a9af2f82bc10fc3a07f049a343073c35effdb018c8d69e58cab7d446239303b4a0647e31cb69ea53e4f2193bf77c3bb53c3b676b4
+  data.tar.gz: ba23033d17a9803d92ba629d1cf4db2ae86b788081a54017cb4443a6122ab69c763f968bb7539429864771e720484a1c85008de5505da48575dcdff23ee76f53

data/CHANGELOG.md

@@ -6,6 +6,30 @@ All notable changes are recorded here. The format follows
 
 ## [Unreleased]
 
+## [0.11.0] - 2026-08-27
+
+### Added
+
+- First-class `progress: :pretty` support for Docker-style application steps with live container output.
+- Support for Dagger's `logs` and `dots` progress frontends.
+
+### Fixed
+
+- Keep engine startup failures visible and reap the complete Dagger process group after completion or interruption.
+
+## [0.10.0] - 2026-08-25
+
+### Added
+
+- Explicit Apple Container and Docker runner selection.
+- Compatible Dagger CLI and engine verification before standalone sessions.
+- Container default-argument, Docker healthcheck, and host image-store export APIs.
+
+### Changed
+
+- Support Ruby 3.2 and newer so Ruby applications do not need Ruby 4 solely to
+  use the Dagger client.
+
 ## [0.9.0] - 2026-08-20
 
 ### Added
@@ -64,7 +88,9 @@ All notable changes are recorded here. The format follows
 
 - Initial container, directory, file, cache, secret, Git, and GraphQL client.
 
-[Unreleased]: https://github.com/boringcache/dagger_ruby/compare/v0.9.0...HEAD
+[Unreleased]: https://github.com/boringcache/dagger_ruby/compare/v0.11.0...HEAD
+[0.11.0]: https://github.com/boringcache/dagger_ruby/compare/v0.10.0...v0.11.0
+[0.10.0]: https://github.com/boringcache/dagger_ruby/compare/v0.9.0...v0.10.0
 [0.9.0]: https://github.com/boringcache/dagger_ruby/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/boringcache/dagger_ruby/releases/tag/v0.8.0
 [0.6.0]: https://github.com/boringcache/dagger_ruby/releases/tag/v0.6.0

data/README.md

@@ -12,7 +12,7 @@ covers a practical subset of the API instead of Dagger module code generation.
 
 ## Requirements
 
-- Ruby 4.0 or newer
+- Ruby 3.2 or newer
 - Dagger 0.21.8
 - Docker, Colima, or another container runtime supported by Dagger
 
@@ -131,18 +131,32 @@ available options.
 ```ruby
 config = DaggerRuby::Config.new(
   timeout: 300,
-  progress: "plain",
+  progress: :pretty,
   log_output: $stderr,
+  runtime: :apple,
 )
 
 DaggerRuby.connection(config) do |client|
-  # Build pipeline
+  progress = config.progress_reporter
+  container = client.container.from("alpine:3.22").with_exec(["apk", "add", "git"])
+  progress.step("[build] RUN apk add git") { container.sync }
 end
 ```
 
+Use `progress: :pretty` for numbered, coloured application steps with live container output.
+Use `:logs` for Dagger's unadorned streaming logs or `:plain` for the complete execution graph.
+The supported modes are `:pretty`, `:auto`, `:plain`, `:tty`, `:dots`, and `:logs`.
+
 `DAGGER_QUIET`, `DAGGER_SILENT`, and `DAGGER_PROGRESS` can provide the same CLI
 preferences through the environment.
 
+The client verifies the installed Dagger CLI before it starts a runner and then
+verifies the connected engine version. This matters for runtime drivers because
+the compatible CLI provisions the runner; merely pointing an older CLI at a
+newer engine image is not sufficient. Use `runtime: :apple` or `runtime: :docker`
+when more than one runtime is installed and automatic detection would be
+ambiguous. A custom runner can be selected with `runner_host:`.
+
 ## Errors
 
 Connection, transport, GraphQL, and invalid-query failures use dedicated error
@@ -158,7 +172,7 @@ end
 
 ## Compatibility
 
-The current branch is tested against Ruby 4.0 and Dagger 0.21.8. Dagger's
+The current branch is tested against maintained Ruby releases and Dagger 0.21.8. Dagger's
 GraphQL schema can change between releases, so each supported engine update is
 validated by the live integration suite before release. Earlier Ruby and Dagger
 versions are not covered by the current compatibility contract.

data/dagger_ruby.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
                      "services, caches, secrets, and filesystem operations with the Dagger engine."
   spec.homepage = "https://github.com/boringcache/dagger_ruby"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 4.0.0"
+  spec.required_ruby_version = ">= 3.2.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 

data/lib/dagger_ruby/config.rb

@@ -1,8 +1,14 @@
 require "logger"
+require_relative "version"
 
 module DaggerRuby
   class Config
-    attr_reader :log_output, :workdir, :timeout, :quiet, :silent, :progress
+    ENGINE_IMAGE = "registry.dagger.io/engine".freeze
+    RUNTIMES = %i[auto apple docker].freeze
+    PROGRESS_MODES = %w[auto pretty plain tty dots logs].freeze
+
+    attr_reader :log_output, :workdir, :timeout, :quiet, :silent, :progress,
+                :runtime, :runner_host, :dagger_version, :verify_version
 
     def initialize(options = {})
       @log_output = options[:log_output]
@@ -10,7 +16,64 @@ module DaggerRuby
       @timeout = options[:timeout] || 600
       @quiet = options[:quiet] || ENV["DAGGER_QUIET"]&.to_i
       @silent = options[:silent] || ENV["DAGGER_SILENT"] == "true"
-      @progress = options[:progress] || ENV.fetch("DAGGER_PROGRESS", nil)
+      @progress = normalize_progress(options[:progress] || ENV.fetch("DAGGER_PROGRESS", nil))
+      @runtime = normalize_runtime(options.fetch(:runtime, ENV.fetch("DAGGER_RUBY_RUNTIME", "auto")))
+      @runner_host = options[:runner_host]
+      @dagger_version = options.fetch(:dagger_version, DAGGER_VERSION).to_s.delete_prefix("v")
+      @verify_version = options.fetch(:verify_version, true)
+
+      raise ArgumentError, "runner_host and runtime cannot both be configured" if @runner_host && @runtime != :auto
+    end
+
+    def environment
+      environment = {}
+      environment["_EXPERIMENTAL_DAGGER_RUNNER_HOST"] = resolved_runner_host if resolved_runner_host
+      environment
+    end
+
+    def expected_engine_version
+      "v#{dagger_version}"
+    end
+
+    def pretty_progress? = progress == "pretty"
+
+    def streaming_logs? = %w[pretty logs].include?(progress)
+
+    def dagger_progress
+      pretty_progress? ? "logs" : progress
+    end
+
+    def progress_reporter(out: $stdout, enabled: true, environment: ENV)
+      enabled &&= pretty_progress?
+      color = enabled && out.respond_to?(:tty?) && out.tty? && !environment.key?("NO_COLOR") &&
+              environment.fetch("TERM", "") != "dumb"
+      Progress.new(out: out, enabled: enabled, streaming: streaming_logs?, color: color,
+                   relay: enabled && Progress::Relay.from_environment(environment))
+    end
+
+    private
+
+    def normalize_runtime(value)
+      runtime = value.to_s.downcase.to_sym
+      return runtime if RUNTIMES.include?(runtime)
+
+      raise ArgumentError, "Unknown Dagger runtime '#{value}'. Use auto, apple, or docker."
+    end
+
+    def normalize_progress(value)
+      return unless value
+
+      progress = value.to_s.downcase
+      return progress if PROGRESS_MODES.include?(progress)
+
+      raise ArgumentError, "Unknown Dagger progress '#{value}'. Use pretty, auto, plain, tty, dots, or logs."
+    end
+
+    def resolved_runner_host
+      return runner_host if runner_host
+      return if runtime == :auto
+
+      "image+#{runtime}://#{ENGINE_IMAGE}:#{expected_engine_version}"
     end
   end
 end

data/lib/dagger_ruby/container.rb

@@ -98,6 +98,26 @@ module DaggerRuby
       chain_operation("withEntrypoint", entrypoint_args)
     end
 
+    def with_default_args(args)
+      chain_operation("withDefaultArgs", { "args" => args })
+    end
+
+    def with_docker_healthcheck(args, opts = {})
+      healthcheck_args = { "args" => args }
+      healthcheck_args["shell"] = opts[:shell] if opts.key?(:shell)
+      healthcheck_args["interval"] = opts[:interval] if opts[:interval]
+      healthcheck_args["timeout"] = opts[:timeout] if opts[:timeout]
+      healthcheck_args["startPeriod"] = opts[:start_period] if opts[:start_period]
+      healthcheck_args["startInterval"] = opts[:start_interval] if opts[:start_interval]
+      healthcheck_args["retries"] = opts[:retries] if opts[:retries]
+
+      chain_operation("withDockerHealthcheck", healthcheck_args)
+    end
+
+    def without_docker_healthcheck
+      chain_operation("withoutDockerHealthcheck")
+    end
+
     def with_user(name)
       chain_operation("withUser", { "name" => name })
     end
@@ -259,6 +279,17 @@ module DaggerRuby
       get_scalar("entrypoint")
     end
 
+    def default_args
+      get_scalar("defaultArgs")
+    end
+
+    def docker_healthcheck
+      get_selection(
+        "dockerHealthcheck",
+        "args shell interval timeout startPeriod startInterval retries",
+      )
+    end
+
     def env_variables
       get_selection("envVariables", "name value")
     end
@@ -305,6 +336,16 @@ module DaggerRuby
       export(path, opts)
     end
 
+    def export_image(name, opts = {})
+      args = { "name" => name }
+      args["platformVariants"] = graphql_ids(opts[:platform_variants]) if opts[:platform_variants]
+      args["forcedCompression"] = QueryBuilder.enum_value(opts[:forced_compression]) if opts[:forced_compression]
+      args["mediaTypes"] = QueryBuilder.enum_value(opts[:media_types]) if opts[:media_types]
+
+      get_scalar("exportImage", args)
+      name
+    end
+
     def publish(address, opts = {})
       args = { "address" => address }
       args["platformVariants"] = graphql_ids(opts[:platform_variants]) if opts[:platform_variants]

data/lib/dagger_ruby/errors.rb

@@ -6,4 +6,5 @@ module DaggerRuby
   class HTTPError < DaggerError; end
   class InvalidQueryError < DaggerError; end
   class ConnectionError < DaggerError; end
+  class VersionMismatchError < ConnectionError; end
 end

data/lib/dagger_ruby/progress.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+
+module DaggerRuby
+  class Progress
+    SOCKET_ENV = "DAGGER_RUBY_PROGRESS_SOCKET"
+
+    class Relay
+      def self.from_environment(environment)
+        path = environment[SOCKET_ENV]
+        new(path) if path
+      end
+
+      def initialize(path)
+        @socket = UNIXSocket.new(path)
+      end
+
+      def emit(event)
+        @socket.puts(JSON.generate(event))
+        @socket.flush
+        raise IOError, "Dagger Ruby progress relay disconnected" unless @socket.gets
+      end
+
+      def close
+        @socket.close unless @socket.closed?
+      end
+    end
+
+    def self.silent
+      @silent ||= new(enabled: false)
+    end
+
+    def initialize(out: $stdout, enabled: true, streaming: false, color: false, relay: nil)
+      @out = out
+      @enabled = enabled
+      @streaming = streaming
+      @color = color
+      @relay = relay
+      @step = 0
+    end
+
+    def streaming? = @streaming
+
+    def step(name)
+      return yield unless @enabled
+
+      number = next_step
+      started_at = monotonic_time
+      start_step(number, name)
+      result = yield
+      finish_step(number, "DONE", elapsed_since(started_at))
+      result
+    rescue Interrupt
+      finish_step(number, "CANCELED", elapsed_since(started_at)) if number
+      raise
+    rescue StandardError
+      finish_step(number, "ERROR", elapsed_since(started_at)) if number
+      raise
+    end
+
+    def write(output = nil)
+      return unless @enabled
+
+      output = yield if block_given?
+      text = output.to_s
+      text.each_line { |line| @out.print "    #{line}" }
+      @out.puts unless text.empty? || text.end_with?("\n")
+    end
+
+    def message(text)
+      return unless @enabled
+      return @relay.emit(type: "message", text: text.to_s) if @relay
+
+      @out.puts text
+      @out.flush
+    end
+
+    def close
+      @relay&.close
+    end
+
+    def render(event)
+      case event.fetch("type")
+      when "message"
+        @out.puts event.fetch("text")
+      when "start"
+        @out.puts step_heading(event.fetch("step"), event.fetch("name"))
+      when "finish"
+        status = event.fetch("status")
+        @out.puts step_result(event.fetch("step"), status, event.fetch("elapsed"), color: status_color(status))
+      end
+      @out.flush
+    end
+
+    private
+
+    def next_step
+      @step += 1
+    end
+
+    def start_step(number, name)
+      return @relay.emit(type: "start", step: number, name: name) if @relay
+
+      @out.puts step_heading(number, name)
+    end
+
+    def finish_step(number, status, elapsed)
+      return @relay.emit(type: "finish", step: number, status: status, elapsed: elapsed) if @relay
+
+      @out.puts step_result(number, status, elapsed, color: status_color(status))
+    end
+
+    def status_color(status)
+      { "DONE" => 32, "CANCELED" => 33 }.fetch(status, 31)
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def elapsed_since(started_at)
+      format("%.1fs", monotonic_time - started_at)
+    end
+
+    def step_heading(number, name)
+      return "##{number} #{name}" unless @color
+
+      highlighted = name.sub(/\A(\[[^\]]+\])/) { paint(_1, 36) }
+                        .sub(/\b(FROM|RUN|COPY)\b/) { paint(_1, 1) }
+      "#{step_number(number)} #{highlighted}"
+    end
+
+    def step_result(number, status, elapsed, color:)
+      return "##{number} #{status} #{elapsed}" unless @color
+
+      "#{step_number(number)} #{paint(status, "1;#{color}")} #{elapsed}"
+    end
+
+    def step_number(number)
+      @color ? paint("##{number}", "1;34") : "##{number}"
+    end
+
+    def paint(text, code)
+      "\e[#{code}m#{text}\e[0m"
+    end
+  end
+end

data/lib/dagger_ruby/progress_runner.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module DaggerRuby
+  class ProgressRunner
+    DAGGER_EXEC_HEADING = /\A(?:\e\[[0-9;]*m)*▼ withExec\b/
+    INTERRUPT_TIMEOUT = 1
+    TERMINATION_TIMEOUT = 1
+
+    def initialize(out: $stderr, result_out: $stdout, environment: ENV)
+      @out = out
+      @result_out = result_out
+      @environment = environment
+      @started = false
+      @started_mutex = Mutex.new
+    end
+
+    def run(command, environment: {})
+      reset_progress_state!
+      Dir.mktmpdir("drp-", "/tmp") do |directory|
+        server = UNIXServer.new(::File.join(directory, "progress.sock"))
+        listener = listen(server)
+        primary_output, primary_writer = IO.pipe
+        primary_reader = relay_primary_output(primary_output)
+        dagger_output, dagger_writer = IO.pipe
+        output_reader = relay_dagger_output(dagger_output)
+        pid = Process.spawn(
+          environment.merge(Progress::SOCKET_ENV => server.path),
+          *command,
+          in: ::File::NULL,
+          out: primary_writer,
+          err: dagger_writer,
+          pgroup: true,
+        )
+        primary_writer.close
+        dagger_writer.close
+        _, status = Process.wait2(pid)
+        clean_process_group(pid)
+        server.close
+        listener.join
+        primary_reader.join
+        output_reader.join
+        exit_status(status)
+      rescue Interrupt
+        terminate(pid)
+        @out.puts "\nBuild canceled."
+        @out.flush
+        130
+      ensure
+        close_io(primary_output)
+        close_io(primary_writer)
+        close_io(dagger_output)
+        close_io(dagger_writer)
+        close_io(server)
+        stop_thread(listener)
+        stop_thread(primary_reader)
+        stop_thread(output_reader)
+      end
+    end
+
+    private
+
+    def listen(server)
+      Thread.new do
+        socket = server.accept
+        renderer = Progress.new(out: @out, color: color?)
+        socket.each_line do |line|
+          renderer.render(JSON.parse(line))
+          progress_started!
+          socket.puts("ok")
+          socket.flush
+        end
+      rescue IOError, Errno::EBADF, Errno::EPIPE
+        nil
+      ensure
+        socket&.close
+      end
+    end
+
+    def relay_dagger_output(input)
+      Thread.new do
+        buffered = []
+        input.each_line do |line|
+          if progress_started?
+            @out.write(line) unless line.match?(DAGGER_EXEC_HEADING)
+            @out.flush
+          else
+            buffered << line
+          end
+        end
+        @out.write(buffered.join) unless progress_started?
+        @out.flush
+      rescue IOError, Errno::EBADF
+        nil
+      ensure
+        input.close unless input.closed?
+      end
+    end
+
+    def relay_primary_output(input)
+      Thread.new do
+        loop do
+          @result_out.write(input.readpartial(4096))
+          @result_out.flush
+        end
+      rescue IOError, Errno::EBADF
+        nil
+      ensure
+        input.close unless input.closed?
+      end
+    end
+
+    def progress_started!
+      @started_mutex.synchronize { @started = true }
+    end
+
+    def reset_progress_state!
+      @started_mutex.synchronize { @started = false }
+    end
+
+    def progress_started?
+      @started_mutex.synchronize { @started }
+    end
+
+    def close_io(io)
+      io.close if io && !io.closed?
+    end
+
+    def stop_thread(thread)
+      return unless thread
+
+      thread.kill if thread.alive?
+      thread.join
+    end
+
+    def terminate(pid)
+      return unless pid
+
+      reaped = false
+      begin
+        signal_process_group("INT", pid)
+        reaped = wait_for_exit(pid, timeout: INTERRUPT_TIMEOUT)
+        if process_group_alive?(pid)
+          signal_process_group("TERM", pid)
+          reaped ||= wait_for_exit(pid, timeout: TERMINATION_TIMEOUT)
+          wait_for_process_group(pid, timeout: TERMINATION_TIMEOUT) if reaped
+        end
+        signal_process_group("KILL", pid) if process_group_alive?(pid)
+      ensure
+        reap(pid) unless reaped
+        wait_for_process_group(pid, timeout: TERMINATION_TIMEOUT)
+      end
+    end
+
+    def clean_process_group(pid)
+      return unless process_group_alive?(pid)
+
+      signal_process_group("TERM", pid)
+      return if wait_for_process_group(pid, timeout: TERMINATION_TIMEOUT)
+
+      signal_process_group("KILL", pid)
+      wait_for_process_group(pid, timeout: TERMINATION_TIMEOUT)
+    end
+
+    def process_group_alive?(pid)
+      Process.kill(0, -pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    def wait_for_process_group(pid, timeout:)
+      deadline = monotonic_time + timeout
+      loop do
+        return true unless process_group_alive?(pid)
+        return false if monotonic_time >= deadline
+
+        sleep 0.05
+      end
+    end
+
+    def signal_process_group(signal, pid)
+      Process.kill(signal, -pid)
+    rescue Errno::ESRCH
+      nil
+    end
+
+    def wait_for_exit(pid, timeout:)
+      deadline = monotonic_time + timeout
+      loop do
+        return true if Process.waitpid(pid, Process::WNOHANG)
+        return false if monotonic_time >= deadline
+
+        sleep 0.05
+      end
+    rescue Errno::ECHILD
+      true
+    end
+
+    def reap(pid)
+      Process.wait(pid)
+    rescue Errno::ECHILD
+      nil
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def exit_status(status)
+      status.exitstatus || (128 + status.termsig)
+    end
+
+    def color?
+      @out.respond_to?(:tty?) && @out.tty? && !@environment.key?("NO_COLOR") &&
+        @environment.fetch("TERM", "") != "dumb"
+    end
+  end
+end

data/lib/dagger_ruby/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module DaggerRuby
-  VERSION = "0.9.0"
+  VERSION = "0.11.0"
   DAGGER_VERSION = "0.21.8"
 end

data/lib/dagger_ruby.rb

@@ -1,16 +1,28 @@
 # frozen_string_literal: true
 
 require_relative "dagger_ruby/version"
+require_relative "dagger_ruby/progress"
+require_relative "dagger_ruby/progress_runner"
 require_relative "dagger_ruby/client"
 require_relative "dagger_ruby/config"
 require_relative "dagger_ruby/errors"
+require "open3"
 
 module DaggerRuby
   class << self
     def connection(config = nil, &)
+      config ||= Config.new
       return connection_in_current_session(config, &) if dagger_session?
 
-      exec(*dagger_run_command(config))
+      verify_cli_version!(config) if config.verify_version
+      if config.pretty_progress?
+        exit ProgressRunner.new.run(dagger_run_command(config), environment: config.environment)
+      end
+      exec(config.environment, *dagger_run_command(config))
+    rescue Interrupt
+      exit 130 if config.pretty_progress?
+
+      raise
     end
 
     private
@@ -21,6 +33,12 @@ module DaggerRuby
 
     def connection_in_current_session(config)
       client = Client.new(config: config)
+      begin
+        verify_engine_version!(client, config) if config.verify_version
+      rescue StandardError
+        client.close
+        raise
+      end
       return client unless block_given?
 
       begin
@@ -30,6 +48,14 @@ module DaggerRuby
       end
     end
 
+    def verify_engine_version!(client, config)
+      actual = client.execute_query("query { version }").fetch("version")
+      return if actual == config.expected_engine_version
+
+      raise VersionMismatchError,
+            "Dagger engine #{actual} is incompatible with this client; expected #{config.expected_engine_version}"
+    end
+
     def dagger_run_command(config)
       [
         "dagger",
@@ -44,6 +70,19 @@ module DaggerRuby
       ]
     end
 
+    def verify_cli_version!(config)
+      stdout, stderr, status = Open3.capture3("dagger", "version")
+      output = [stdout, stderr].join(" ").strip
+      actual = output[/\bv\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?\b/]
+      return if status.success? && actual == config.expected_engine_version
+
+      found = actual || (output.empty? ? "an unreadable version" : output)
+      raise VersionMismatchError,
+            "Dagger CLI #{found} is incompatible with this client; install #{config.expected_engine_version}"
+    rescue Errno::ENOENT
+      raise VersionMismatchError, "Dagger CLI is not installed; install #{config.expected_engine_version}"
+    end
+
     def quiet_flags(config)
       quiet = config&.quiet || ENV["DAGGER_QUIET"]&.to_i
       quiet&.positive? ? ["-q"] * quiet : []
@@ -54,7 +93,7 @@ module DaggerRuby
     end
 
     def progress_option(config)
-      progress = config&.progress || ENV.fetch("DAGGER_PROGRESS", nil)
+      progress = config&.dagger_progress || ENV.fetch("DAGGER_PROGRESS", nil)
       progress ? ["--progress", progress] : []
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dagger_ruby
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - BoringCache
@@ -75,6 +75,8 @@ files:
 - lib/dagger_ruby/file.rb
 - lib/dagger_ruby/git_repository.rb
 - lib/dagger_ruby/host.rb
+- lib/dagger_ruby/progress.rb
+- lib/dagger_ruby/progress_runner.rb
 - lib/dagger_ruby/query_builder.rb
 - lib/dagger_ruby/secret.rb
 - lib/dagger_ruby/service.rb
@@ -85,7 +87,7 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/boringcache/dagger_ruby
-  source_code_uri: https://github.com/boringcache/dagger_ruby/tree/v0.9.0
+  source_code_uri: https://github.com/boringcache/dagger_ruby/tree/v0.11.0
   changelog_uri: https://github.com/boringcache/dagger_ruby/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/boringcache/dagger_ruby/issues
   documentation_uri: https://github.com/boringcache/dagger_ruby#readme
@@ -98,7 +100,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 4.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="