dagger_ruby 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a4bcab9db019b25e782aab84ab1e3b154bda15f64cb7d1ffdd522d14cbfb729
-  data.tar.gz: 41e902336fe58545784c21e85a17cc55961a9aab6ad2c6370547ffb4d4779eb5
+  metadata.gz: 61be4b7342e4586fce56e0802de200a7231c85e8f2781ff94b7b8d987f265db3
+  data.tar.gz: d2cde21a762e08d63e345e6c1c1bd5890fc2e48e1b60f65eb8782c003f9ce2a6
 SHA512:
-  metadata.gz: 897cdcb244f34e704a70f2bb47fdeadeb946c2c29e0fff763cf0b487122657a11d2bee3d664593c0b268baf45eba0cbf9b8da1e889eb601e1f4ad6ed7056e1b2
-  data.tar.gz: c52a3cfff5a10a1ef6c8bc1e522c56bf423642dbfbc57bcc76c03e84a61e31e8f346a8157bffb53e112d2a77cdfd044b6d4c562784f9afa785f0460d02f98864
+  metadata.gz: d10eff81b4a146a80bf6945e163318b78b59e0ed6cabe4052652af84795b6ae5ccce0c75f4d385258a7275160d9ea36d13ecddf706a1b3a33ad8a135a0ec489c
+  data.tar.gz: 999a2aa2e9e994425f77f8830fd621493d67f6ad6f37a0984b6c5065ab155b8cb4b82feb2aac968b9636e3996ee6c2f0c33ebdbee7e3ed26d9d442a5a81d64ea

data/CHANGELOG.md

@@ -6,6 +6,28 @@ All notable changes are recorded here. The format follows
 
 ## [Unreleased]
 
+## [0.11.1] - 2026-10-02
+
+### Changed
+
+- Update development dependencies.
+- Update the supported Dagger CLI and engine from 0.21.8 to 0.21.9.
+
+### Fixed
+
+- Show an engine startup status in pretty progress mode when Dagger takes more than one second to start.
+
+## [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
@@ -77,7 +99,8 @@ 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.10.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

data/README.md

@@ -13,7 +13,7 @@ covers a practical subset of the API instead of Dagger module code generation.
 ## Requirements
 
 - Ruby 3.2 or newer
-- Dagger 0.21.8
+- Dagger 0.21.9
 - Docker, Colima, or another container runtime supported by Dagger
 
 ## Installation
@@ -131,16 +131,22 @@ 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.
 
@@ -166,7 +172,7 @@ end
 
 ## Compatibility
 
-The current branch is tested against maintained Ruby releases and Dagger 0.21.8. Dagger's
+The current branch is tested against maintained Ruby releases and Dagger 0.21.9. 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/lib/dagger_ruby/config.rb

@@ -5,6 +5,7 @@ module DaggerRuby
   class Config
     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
@@ -15,7 +16,7 @@ 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")
@@ -34,6 +35,22 @@ module DaggerRuby
       "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)
@@ -43,6 +60,15 @@ module DaggerRuby
       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

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,241 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module DaggerRuby
+  class ProgressRunner
+    DAGGER_EXEC_HEADING = /\A(?:\e\[[0-9;]*m)*▼ withExec\b/
+    INTERRUPT_TIMEOUT = 1
+    STARTUP_NOTICE_DELAY = 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
+        startup_notice = report_slow_startup
+        _, 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)
+        stop_thread(startup_notice)
+      end
+    end
+
+    private
+
+    def listen(server)
+      Thread.new do
+        socket = server.accept
+        renderer = Progress.new(out: @out, color: color?)
+        socket.each_line do |line|
+          render_progress(renderer, JSON.parse(line))
+          socket.puts("ok")
+          socket.flush
+        end
+      rescue IOError, Errno::EBADF, Errno::EPIPE
+        nil
+      ensure
+        socket&.close
+      end
+    end
+
+    def report_slow_startup
+      Thread.new do
+        sleep startup_notice_delay
+        @started_mutex.synchronize do
+          next if @started
+
+          @out.puts "Dagger is still starting. It may be downloading the engine image."
+          @out.flush
+        end
+      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 render_progress(renderer, event)
+      @started_mutex.synchronize do
+        @started = true
+        renderer.render(event)
+      end
+    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 startup_notice_delay
+      STARTUP_NOTICE_DELAY
+    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.10.0"
-  DAGGER_VERSION = "0.21.8"
+  VERSION = "0.11.1"
+  DAGGER_VERSION = "0.21.9"
 end

data/lib/dagger_ruby.rb

@@ -1,6 +1,8 @@
 # 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"
@@ -13,7 +15,14 @@ module DaggerRuby
       return connection_in_current_session(config, &) if dagger_session?
 
       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
@@ -84,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.10.0
+  version: 0.11.1
 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.10.0
+  source_code_uri: https://github.com/boringcache/dagger_ruby/tree/v0.11.1
   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