boringbuilder 0.1.0.alpha.1 → 0.1.0.alpha.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e20e908005e1a14c27c241b1540be57b73b7fa20f4a79513a22ce9535149fce4
-  data.tar.gz: e7b7c17cf76c2fcc852dd03765c1002bb8c32a993d3aac87b0b0561ac8e7a382
+  metadata.gz: 823ab9ebc22d049c27671d07ea1be44315dbdf3f63cdd29c46cd209e6e5fc279
+  data.tar.gz: 58c38219ef59ff3bf7515d10140be7500784bf276f5b0ea71edd965d7ae10b86
 SHA512:
-  metadata.gz: 3950b539d458467b05b258bceb0d0e5a04f1c08fbb3dc1943db5f2750200c337694459090e5318334910be42f03495f260d134044e9a61fb4c6d4806bf4e5d9e
-  data.tar.gz: a7c8ee8d4b21afa7362c5f15846f943eff9ef1009c40b3860eae2802cddac826a25c6bd12e8c182468237378630cfbb0dbb53c2d9d5d6d6a020976ca37e20537
+  metadata.gz: 7812ac305fa0015e0007049f6272a81fcf237db37304522323bad5a7a9947ac2f6e77d9e9788cf57490c31d680c17bda5aa3cc025cc19a4b310f9711b080d907
+  data.tar.gz: 67a48f5ce9298763f588c2e979a3bcca6b1a38a9c8f9350597f82876c69168c644b480affc62728d27ad1c8d114071267fbc7592a5703446441dc385b3459357

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.0.alpha.3 - 2026-08-27
+
+- Remove Bundler cache metadata before compiling assets so cold and restored Rails builds stay identical.
+
+## 0.1.0.alpha.2 - 2026-08-27
+
+- Stream clean, Docker-style build steps and command output through Dagger Ruby.
+- Run Bundler with the available CPUs unless `BUNDLE_JOBS` is explicitly configured.
+- Keep dependency cache metadata out of Rails artifacts.
+
 ## 0.1.0.alpha.1 - 2026-08-27
 
 - Reintroduce BoringBuilder as a Ruby gem backed by Dagger Ruby.

data/lib/boringbuilder/builder.rb

@@ -6,7 +6,7 @@ module BoringBuilder
   class Builder
     attr_reader :configuration, :progress
 
-    def initialize(configuration, progress: BuildProgress.silent)
+    def initialize(configuration, progress: DaggerRuby::Progress.silent)
       @configuration = configuration
       @progress = progress
     end

data/lib/boringbuilder/cli.rb

@@ -59,7 +59,7 @@ module BoringBuilder
     end
 
     def build
-      options = {}
+      options = { progress: "pretty" }
       config_file = :auto
       dry_run = false
       json = false
@@ -71,6 +71,8 @@ module BoringBuilder
       return 0 if help_requested
       raise OptionParser::InvalidArgument, "expected at most one PROJECT directory" if @argv.length > 1
 
+      options[:progress] = nil if json
+
       configuration = BoringBuilder.configuration(root: @argv.first || Dir.pwd, config: config_file, **options)
       project = Project.new(configuration).validate!
       if dry_run
@@ -78,8 +80,9 @@ module BoringBuilder
         return 0
       end
 
-      print_build_start(project, json: json)
-      result = @builder_class.new(configuration, progress: build_progress(configuration, json: json)).build
+      progress = build_progress(configuration, json: json)
+      print_build_start(project, json: json, progress: progress)
+      result = @builder_class.new(configuration, progress: progress).build
       json ? @out.puts(JSON.generate(result.to_h)) : print_result(result)
       0
     end
@@ -109,7 +112,8 @@ module BoringBuilder
       parser.on("--platform PLATFORM", "Target platform, for example linux/amd64") do |value|
         options[:platform] = value
       end
-      parser.on("--progress MODE", %w[auto plain tty], "Dagger progress: auto, plain, or tty") do |value|
+      parser.on("--progress MODE", %w[pretty auto plain tty dots logs],
+                "Build progress: pretty (default), auto, plain, tty, dots, or logs") do |value|
         options[:progress] = value
       end
     end
@@ -209,7 +213,7 @@ module BoringBuilder
       @out.puts "Artifact: #{result.artifact_id} (#{result.artifact_name})" if result.artifact_published?
     end
 
-    def print_build_start(project, json:)
+    def print_build_start(project, json:, progress:)
       return if json || !dagger_session?
 
       cache = BoringCache.new(project, nil, environment: @environment).mode
@@ -217,8 +221,7 @@ module BoringBuilder
       details = [pipeline, "#{project.configuration.runtime} runtime", "#{cache} cache",
                  "#{project.configuration.format.to_s.tr('_', '.')} output"]
 
-      @out.puts "Building #{project.app_name} with Dagger"
-      @out.puts "  #{details.join(' · ')}"
+      progress.message("Building #{project.app_name} with Dagger\n  #{details.join(' · ')}")
     end
 
     def dagger_session?
@@ -226,9 +229,8 @@ module BoringBuilder
     end
 
     def build_progress(configuration, json:)
-      enabled = !json && dagger_session? && configuration.progress.nil?
-      animated = enabled && @out.respond_to?(:tty?) && @out.tty?
-      BuildProgress.new(out: @out, enabled: enabled, animated: animated)
+      config = DaggerRuby::Config.new(progress: configuration.progress, verify_version: false)
+      config.progress_reporter(out: @out, enabled: !json && dagger_session?, environment: @environment)
     end
   end
 end

data/lib/boringbuilder/exporter.rb

@@ -10,7 +10,7 @@ module BoringBuilder
     attr_reader :project, :client, :container, :runtime, :exporters, :progress
 
     def initialize(project, client, container, runtime:, command_runner: nil, exporters: nil,
-                   progress: BuildProgress.silent)
+                   progress: DaggerRuby::Progress.silent)
       @project = project
       @client = client
       @container = container
@@ -56,33 +56,36 @@ module BoringBuilder
     end
 
     def export_step_name(adapter)
-      return "Publish artifact to BoringCache" if adapter.name == :boringcache
+      return "[export] Publish artifact to BoringCache" if adapter.name == :boringcache
 
-      "Export #{configuration.format.to_s.tr('_', '.')} artifact"
+      "[export] Write #{configuration.format.to_s.tr('_', '.')} artifact"
     end
 
     def build_asset
       filename = project.output_path.basename.to_s
       case configuration.format
       when :directory
-        Exporters::Asset.new(kind: :directory, source: artifact_directory, filename: filename)
+        Exporters::Asset.new(kind: :directory, source: prepared_artifact_directory, filename: filename)
       when :tar
         Exporters::Asset.new(kind: :file, source: archive_file("artifact.tar", compression: nil), filename: filename)
       when :tar_zst
         Exporters::Asset.new(kind: :file, source: archive_file("artifact.tar.zst", compression: :zstd),
                              filename: filename)
       when :oci, :docker
-        Exporters::Asset.new(kind: :file, source: container.as_tarball(media_types: media_types), filename: filename)
+        source = progress.step("[export] Create #{configuration.format.to_s.upcase} image archive") do
+          container.as_tarball(media_types: media_types).sync
+        end
+        Exporters::Asset.new(kind: :file, source: source, filename: filename)
       end
     end
 
     def export_reference
       if configuration.publish
-        progress.step("Publish container image") do
+        progress.step("[export] Publish container image") do
           container.publish(configuration.publish, media_types: media_types)
         end
       elsif configuration.load
-        progress.step("Load container image") { load_image }
+        progress.step("[export] Load container image") { load_image }
       end
     end
 
@@ -123,20 +126,48 @@ module BoringBuilder
       @artifact_directory ||= project.artifact.export_directory(client, container)
     end
 
+    def prepared_artifact_directory
+      @prepared_artifact_directory ||= progress.step("[export] Assemble artifact filesystem") do
+        artifact_directory.sync
+      end
+    end
+
     def archive_file(filename, compression:)
-      packer = client.container.from(PACKER_IMAGE).with_exec(%w[apk add --no-cache tar zstd])
-      packer = packer.with_mounted_directory("/artifact", artifact_directory)
+      packer = progress.step("[export] FROM #{PACKER_IMAGE}") { client.container.from(PACKER_IMAGE).sync }
+      packer = run_archive_step(packer, %w[apk add --no-cache tar zstd], "[export] RUN apk add tar zstd")
+      packer = packer.with_mounted_directory("/artifact", prepared_artifact_directory)
       tar_path = compression == :zstd ? "/artifact.tar" : "/#{filename}"
-      packer = packer.with_exec(
+      packer = run_archive_step(
+        packer,
         [
           "tar", "--sort=name", "--mtime=@0", "--owner=0", "--group=0", "--numeric-owner",
           "--pax-option=delete=atime,delete=ctime", "-C", "/artifact", "-cf", tar_path, "."
-        ]
+        ],
+        "[export] RUN tar -cf #{tar_path} ."
       )
-      packer = packer.with_exec(["zstd", "-q", "-T1", tar_path, "-o", "/#{filename}"]) if compression == :zstd
+      if compression == :zstd
+        packer = run_archive_step(
+          packer,
+          ["zstd", "-q", "-T0", tar_path, "-o", "/#{filename}"],
+          "[export] RUN zstd -T0 #{tar_path}"
+        )
+      end
       packer.file("/#{filename}")
     end
 
+    def run_archive_step(container, command, name)
+      executed = container.with_exec(command)
+      progress.step(name) do
+        output = command_output(executed)
+        progress.write(output) unless progress.streaming?
+        executed.sync
+      end
+    end
+
+    def command_output(container)
+      [container.stdout, container.stderr].map(&:strip).reject(&:empty?).join("\n")
+    end
+
     def media_types
       configuration.format == :docker ? :DockerMediaTypes : :OCIMediaTypes
     end

data/lib/boringbuilder/mise.rb

@@ -40,7 +40,7 @@ module BoringBuilder
         at: CACHE_PATH,
         entry: "mise",
         workdir: workdir,
-        name: "Prepare Mise toolchain"
+        name: "[build] RUN #{command.join(' ')}"
       )
     end
 

data/lib/boringbuilder/pipeline.rb

@@ -4,7 +4,7 @@ module BoringBuilder
   class Pipeline
     attr_reader :project, :client, :progress
 
-    def initialize(project, client, environment: ENV, progress: BuildProgress.silent)
+    def initialize(project, client, environment: ENV, progress: DaggerRuby::Progress.silent)
       @project = project
       @client = client
       @environment = environment
@@ -124,7 +124,10 @@ module BoringBuilder
       return container if container.equal?(@last_synced_container)
 
       @last_synced_container = progress.step(name) do
-        progress.write { output.call } if output
+        if output
+          result = output.call
+          progress.write(result) unless progress.streaming?
+        end
         container.sync
       end
     end

data/lib/boringbuilder/project.rb

@@ -5,6 +5,7 @@ module BoringBuilder
     DEFAULT_EXCLUDES = %w[
       .env
       .env.*
+      .bundle/cache
       .git
       coverage
       dist
@@ -29,7 +30,7 @@ module BoringBuilder
       self
     end
 
-    def container(client, progress: BuildProgress.silent)
+    def container(client, progress: DaggerRuby::Progress.silent)
       return Pipeline.new(self, client, progress: progress).build(&configuration.pipeline) if custom_pipeline?
 
       builder = rails? ? RailsBuild : RubyBuild

data/lib/boringbuilder/ruby_build.rb

@@ -20,23 +20,29 @@ module BoringBuilder
       "BUNDLE_CLEAN" => "true",
       "BUNDLE_DEPLOYMENT" => "1",
       "BUNDLE_IGNORE_CONFIG" => "true",
-      "BUNDLE_JOBS" => "1",
       "BUNDLE_PATH" => "/usr/local/bundle",
       "BUNDLE_WITHOUT" => "development:test"
     }.freeze
-    BUNDLE_INSTALL_COMMAND = ["sh", "-c", "bundle install && bundle clean --force"].freeze
+    BUNDLE_INSTALL_COMMAND = [
+      "sh", "-c",
+      'export BUNDLE_JOBS="${BUNDLE_JOBS:-$(nproc)}"; bundle install && bundle clean --force'
+    ].freeze
+    APT_INSTALL_COMMAND = [
+      "sh", "-c",
+      "apt-get update && apt-get install -y --no-install-recommends \"$@\" && rm -rf /var/lib/apt/lists/*",
+      "apt-get"
+    ].freeze
     BUNDLE_FILES = %w[Gemfile Gemfile.lock .ruby-version].freeze
     BUNDLE_CONFIG = <<~YAML
       ---
       BUNDLE_PATH: "vendor/bundle"
       BUNDLE_WITHOUT: "development:test"
-      BUNDLE_JOBS: "1"
       BUNDLE_CLEAN: "true"
     YAML
 
     attr_reader :project, :client, :progress
 
-    def initialize(project, client, progress: BuildProgress.silent)
+    def initialize(project, client, progress: DaggerRuby::Progress.silent)
       @project = project
       @client = client
       @progress = progress
@@ -44,15 +50,27 @@ module BoringBuilder
 
     def container
       builder = with_environment(build_image_container, build_environment)
-      builder = install_packages(builder, (BUILD_PACKAGES + configuration.build_packages).uniq)
-      builder = create_application_user(builder)
+      builder = install_packages(builder, (BUILD_PACKAGES + configuration.build_packages).uniq, stage: :build)
+      builder = create_application_user(builder, stage: :build)
       builder = install_toolchain(builder)
       builder = install_gems(builder)
-      builder = builder.with_directory(application_path, project.source(client), owner: user_owner)
-      builder = builder.with_workdir(application_path).with_exec(%w[bundle check])
+      builder = pipeline.step("[build] COPY application source", builder) do |container|
+        container.with_directory(application_path, project.source(client), owner: user_owner)
+      end
+      builder = pipeline.exec(
+        builder,
+        %w[bundle check],
+        name: "[build] RUN bundle check",
+        workdir: application_path
+      )
+      builder = pipeline.exec(
+        builder,
+        %w[rm -rf .bundle/cache],
+        name: "[build] RUN rm -rf .bundle/cache",
+        workdir: application_path
+      )
       builder = precompile(builder)
-      builder = write_bundle_config(builder)
-      builder = progress.step("Build #{project.framework.to_s.capitalize} application") { builder.sync }
+      builder = pipeline.step("[build] Write Bundler configuration", builder) { write_bundle_config(_1) }
 
       runtime_container(builder)
     end
@@ -77,12 +95,12 @@ module BoringBuilder
 
     def build_image_container
       address = configuration.base_image || DEFAULT_BUILD_IMAGE
-      client.container(image_options).from(address)
+      progress.step("[build] FROM #{address}") { client.container(image_options).from(address).sync }
     end
 
     def runtime_image_container
       address = configuration.base_image || DEFAULT_RUNTIME_IMAGE
-      client.container(image_options).from(address)
+      progress.step("[runtime] FROM #{address}") { client.container(image_options).from(address).sync }
     end
 
     def build_environment
@@ -119,7 +137,7 @@ module BoringBuilder
         cache: "bundle",
         at: "/usr/local/bundle/cache",
         entry: "bundler",
-        name: "Install gems"
+        name: "[build] RUN bundle install"
       )
       container.with_exec(["find", "/usr/local/bundle", "-path", "*/cache/*.gem", "-type", "f", "-delete"])
                .with_exec([
@@ -130,6 +148,7 @@ module BoringBuilder
 
     def write_bundle_config(container)
       container.with_workdir(application_path)
+               .with_exec(%w[rm -rf .bundle/cache])
                .with_exec(%w[mkdir -p .bundle])
                .with_new_file("#{application_path}/.bundle/config", BUNDLE_CONFIG)
     end
@@ -140,41 +159,59 @@ module BoringBuilder
 
     def runtime_container(builder)
       container = with_environment(runtime_image_container, Mise::ENVIRONMENT.merge(runtime_environment))
-      container = install_packages(container, (RUNTIME_PACKAGES + configuration.runtime_packages).uniq)
-      container = create_application_user(container)
-      container = container.with_directory("/mise/installs", builder.directory("/mise/installs"))
-                           .with_directory("/usr/local/bundle", builder.directory("/usr/local/bundle"),
-                                           owner: user_owner)
-                           .with_directory(application_path, builder.directory(application_path), owner: user_owner)
-                           .with_workdir(application_path)
-                           .with_exec(%w[mise reshim])
+      container = install_packages(container, (RUNTIME_PACKAGES + configuration.runtime_packages).uniq,
+                                   stage: :runtime)
+      container = create_application_user(container, stage: :runtime)
+      container = pipeline.step("[runtime] COPY toolchain, gems, and application", container) do |runtime|
+        runtime.with_directory("/mise/installs", builder.directory("/mise/installs"))
+               .with_directory("/usr/local/bundle", builder.directory("/usr/local/bundle"), owner: user_owner)
+               .with_directory(application_path, builder.directory(application_path), owner: user_owner)
+      end
+      container = pipeline.exec(
+        container,
+        %w[mise reshim],
+        name: "[runtime] RUN mise reshim",
+        workdir: application_path
+      )
       container = runtime_metadata(container).with_user(project.application_user)
-      progress.step("Assemble runtime image") { container.sync }
+      progress.step("[runtime] Configure image") { container.sync }
     end
 
-    def install_packages(container, packages)
-      container
-        .with_exec(%w[apt-get update])
-        .with_exec(["apt-get", "install", "-y", "--no-install-recommends", *packages])
-        .with_exec(%w[rm -rf /var/lib/apt/lists])
+    def install_packages(container, packages, stage:)
+      pipeline.exec(
+        container,
+        [*APT_INSTALL_COMMAND, *packages],
+        name: "[#{stage}] RUN apt-get update && apt-get install packages"
+      )
     end
 
-    def create_application_user(container)
+    def create_application_user(container, stage:)
       name = project.application_user
-      container
-        .with_exec(["groupadd", "--system", "--gid", "1000", name])
-        .with_exec(["useradd", name, "--uid", "1000", "--gid", "1000", "--create-home", "--shell", "/bin/bash"])
+      pipeline.step("[#{stage}] Create application user", container) do |step|
+        step.with_exec(["groupadd", "--system", "--gid", "1000", name])
+            .with_exec(["useradd", name, "--uid", "1000", "--gid", "1000", "--create-home", "--shell", "/bin/bash"])
+      end
     end
 
     def precompile(container)
-      container = container.with_exec(%w[bin/rails assets:precompile]) if project.rails? && project.assets?
+      if project.rails? && project.assets?
+        container = pipeline.exec(
+          container,
+          %w[bin/rails assets:precompile],
+          name: "[build] RUN bin/rails assets:precompile"
+        )
+      end
       if project.bootsnap?
         paths = project.rails? ? %w[app/ lib/] : %w[app/ lib/ config/]
-        container = container.with_exec(["bundle", "exec", "bootsnap", "precompile", "--gemfile", *paths])
+        container = pipeline.exec(
+          container,
+          ["bundle", "exec", "bootsnap", "precompile", "--gemfile", *paths],
+          name: "[build] RUN bundle exec bootsnap precompile"
+        )
       end
       return container unless project.rails?
 
-      normalize_rails_output(container)
+      pipeline.step("[build] Normalize Rails output", container) { normalize_rails_output(_1) }
     end
 
     def normalize_rails_output(container)

data/lib/boringbuilder/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BoringBuilder
-  VERSION = "0.1.0.alpha.1"
+  VERSION = "0.1.0.alpha.3"
 end

data/lib/boringbuilder.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
+require "dagger_ruby"
+
 require_relative "boringbuilder/version"
 require_relative "boringbuilder/errors"
 require_relative "boringbuilder/artifact"
 require_relative "boringbuilder/configuration"
 require_relative "boringbuilder/config_file"
 require_relative "boringbuilder/initializer"
-require_relative "boringbuilder/build_progress"
 require_relative "boringbuilder/boring_cache"
 require_relative "boringbuilder/mise"
 require_relative "boringbuilder/pipeline"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: boringbuilder
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha.1
+  version: 0.1.0.alpha.3
 platform: ruby
 authors:
 - BoringCache
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-27 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dagger_ruby
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.11'
 description: BoringBuilder turns application source into filesystem artifacts and
   container images. Rails is first class, while Mise-powered Dagger Ruby recipes support
   any workload.
@@ -48,7 +47,6 @@ files:
 - lib/boringbuilder.rb
 - lib/boringbuilder/artifact.rb
 - lib/boringbuilder/boring_cache.rb
-- lib/boringbuilder/build_progress.rb
 - lib/boringbuilder/builder.rb
 - lib/boringbuilder/cli.rb
 - lib/boringbuilder/config_file.rb
@@ -80,13 +78,12 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/boringcache/builder
-  source_code_uri: https://github.com/boringcache/builder/tree/v0.1.0.alpha.1
+  source_code_uri: https://github.com/boringcache/builder/tree/v0.1.0.alpha.3
   documentation_uri: https://github.com/boringcache/builder#readme
   changelog_uri: https://github.com/boringcache/builder/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/boringcache/builder/issues
   security_policy_uri: https://github.com/boringcache/builder/security/policy
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -97,12 +94,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Build deployment artifacts and images with Dagger
 test_files: []

data/lib/boringbuilder/build_progress.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module BoringBuilder
-  class BuildProgress
-    SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
-
-    def self.silent
-      @silent ||= new(enabled: false)
-    end
-
-    def initialize(out: $stdout, enabled: true, animated: false)
-      @out = out
-      @enabled = enabled
-      @animated = animated
-      @step = 0
-    end
-
-    def step(name)
-      return yield unless @enabled
-
-      number = next_step
-      started_at = monotonic_time
-      @out.puts "##{number} #{name}"
-      @active_spinner = start_spinner(number, started_at)
-      result = yield
-      stop_active_spinner
-      @out.puts "##{number} DONE #{elapsed_since(started_at)}"
-      result
-    rescue StandardError
-      stop_active_spinner
-      @out.puts "##{number} ERROR #{elapsed_since(started_at)}" if number
-      raise
-    ensure
-      stop_active_spinner
-    end
-
-    def write(output = nil)
-      return unless @enabled
-
-      output = yield if block_given?
-      stop_active_spinner
-      text = output.to_s
-      text.each_line { |line| @out.print "    #{line}" }
-      @out.puts unless text.empty? || text.end_with?("\n")
-    end
-
-    private
-
-    def next_step
-      @step += 1
-    end
-
-    def start_spinner(number, started_at)
-      return unless @animated
-
-      Thread.new do
-        frame = 0
-        loop do
-          @out.print "\r##{number} #{SPINNER_FRAMES.fetch(frame % SPINNER_FRAMES.length)} #{elapsed_since(started_at)}"
-          @out.flush
-          frame += 1
-          sleep 0.1
-        end
-      rescue IOError
-        nil
-      end
-    end
-
-    def stop_spinner(thread)
-      return unless thread&.alive?
-
-      thread.kill
-      thread.join
-      @out.print "\r\e[2K"
-    end
-
-    def stop_active_spinner
-      stop_spinner(@active_spinner)
-      @active_spinner = nil
-    end
-
-    def monotonic_time
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
-
-    def elapsed_since(started_at)
-      format("%.1fs", monotonic_time - started_at)
-    end
-  end
-end