dagger_ruby 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a4bcab9db019b25e782aab84ab1e3b154bda15f64cb7d1ffdd522d14cbfb729
-  data.tar.gz: 41e902336fe58545784c21e85a17cc55961a9aab6ad2c6370547ffb4d4779eb5
+  metadata.gz: ebaf58b886e0c88802e55c2abb2f10676c4b00466dfd24fc69d6f38ead563e6a
+  data.tar.gz: ad9abb4ee776703af437e713bf3d61a99b80e0f0d9586dadda2a98c689faedf7
 SHA512:
-  metadata.gz: 897cdcb244f34e704a70f2bb47fdeadeb946c2c29e0fff763cf0b487122657a11d2bee3d664593c0b268baf45eba0cbf9b8da1e889eb601e1f4ad6ed7056e1b2
-  data.tar.gz: c52a3cfff5a10a1ef6c8bc1e522c56bf423642dbfbc57bcc76c03e84a61e31e8f346a8157bffb53e112d2a77cdfd044b6d4c562784f9afa785f0460d02f98864
+  metadata.gz: ac82debf94e095271f87339a9af2f82bc10fc3a07f049a343073c35effdb018c8d69e58cab7d446239303b4a0647e31cb69ea53e4f2193bf77c3bb53c3b676b4
+  data.tar.gz: ba23033d17a9803d92ba629d1cf4db2ae86b788081a54017cb4443a6122ab69c763f968bb7539429864771e720484a1c85008de5505da48575dcdff23ee76f53

data/CHANGELOG.md

@@ -6,6 +6,17 @@ 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
@@ -77,7 +88,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

@@ -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.
 

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,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.10.0"
+  VERSION = "0.11.0"
   DAGGER_VERSION = "0.21.8"
 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.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.10.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