boringbuilder 0.1.0.alpha.1

data/lib/boringbuilder/ruby_application.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class RubyApplication
+    attr_reader :root, :configuration
+
+    def initialize(root, configuration)
+      @root = root
+      @configuration = configuration
+    end
+
+    def ruby?
+      root.join("Gemfile").file?
+    end
+
+    def rails?
+      ruby? && root.join("config/application.rb").file?
+    end
+
+    def hanami?
+      ruby? && root.join("config/app.rb").file?
+    end
+
+    def framework
+      return unless ruby?
+      return :rails if rails?
+      return :hanami if hanami?
+      return :rack if rack?
+
+      :ruby
+    end
+
+    def path
+      rails? ? "/rails" : "/app"
+    end
+
+    def user
+      rails? ? "rails" : "app"
+    end
+
+    def runtime_environment
+      environment = {
+        "PORT" => port.to_s,
+        "RACK_ENV" => "production"
+      }
+      environment.merge!(rails_environment) if rails?
+      environment.merge!("HANAMI_ENV" => "production", "HANAMI_PORT" => port.to_s) if hanami?
+      environment
+    end
+
+    def runtime_command
+      configuration.command ? explicit_command : detected_command
+    end
+
+    def runtime_entrypoint
+      return [] if configuration.command || procfile_command
+      return %w[/rails/bin/docker-entrypoint] if rails? && docker_entrypoint?
+      return %w[/rails/bin/rails] if rails?
+
+      []
+    end
+
+    def runtime_port
+      port
+    end
+
+    def web?
+      rails? || hanami? || rack? || !procfile_command.nil?
+    end
+
+    private
+
+    def detected_command
+      return procfile_command if procfile_command
+      return rails_command if rails?
+      return hanami_command if hanami?
+      return rack_command if rack?
+      return %w[bundle exec rake] if root.join("Rakefile").file?
+
+      []
+    end
+
+    def explicit_command
+      command = configuration.command
+      return command.map(&:to_s) if command.is_a?(Array)
+
+      ["/bin/sh", "-lc", command.to_s]
+    end
+
+    def rails_command
+      return %w[./bin/thrust ./bin/rails server] if thrust?
+
+      docker_entrypoint? ? %w[./bin/rails server] : %w[server]
+    end
+
+    def hanami_command
+      return %w[bundle exec puma -C config/puma.rb] if root.join("config/puma.rb").file?
+      return rack_command if rack?
+
+      []
+    end
+
+    def rack_command
+      ["bundle", "exec", "rackup", "config.ru", "--host", "0.0.0.0", "--port", port.to_s]
+    end
+
+    def procfile_command
+      return @procfile_command if defined?(@procfile_command)
+
+      path = root.join("Procfile")
+      @procfile_command = if path.file?
+                            command = path.each_line.filter_map { |line| line[/\Aweb:\s*(.+)\s*\z/, 1] }.first
+                            ["/bin/sh", "-lc", command] if command
+                          end
+    end
+
+    def rack?
+      root.join("config.ru").file?
+    end
+
+    def docker_entrypoint?
+      root.join("bin/docker-entrypoint").file?
+    end
+
+    def thrust?
+      root.join("bin/thrust").file?
+    end
+
+    def port
+      configuration.port || (rails? && thrust? ? 80 : 3000)
+    end
+
+    def rails_environment
+      {
+        "NODE_ENV" => "production",
+        "RAILS_ENV" => "production",
+        "RAILS_LOG_TO_STDOUT" => "true",
+        "RAILS_SERVE_STATIC_FILES" => "true"
+      }
+    end
+  end
+end

data/lib/boringbuilder/ruby_build.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class RubyBuild
+    DEFAULT_BUILD_IMAGE = Mise::DEFAULT_IMAGE
+    DEFAULT_RUNTIME_IMAGE = BoringCache::CLI_IMAGE
+    BUILD_PACKAGES = %w[
+      build-essential
+      curl
+      git
+      libpq-dev
+      libyaml-dev
+      pkg-config
+    ].freeze
+    RUNTIME_PACKAGES = %w[
+      curl
+      libpq5
+    ].freeze
+    BUNDLE_ENVIRONMENT = {
+      "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_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)
+      @project = project
+      @client = client
+      @progress = progress
+    end
+
+    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_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 = precompile(builder)
+      builder = write_bundle_config(builder)
+      builder = progress.step("Build #{project.framework.to_s.capitalize} application") { builder.sync }
+
+      runtime_container(builder)
+    end
+
+    private
+
+    def configuration
+      project.configuration
+    end
+
+    def application_path
+      project.application_path
+    end
+
+    def user_owner
+      "#{project.application_user}:#{project.application_user}"
+    end
+
+    def image_options
+      configuration.platform ? { platform: configuration.platform } : {}
+    end
+
+    def build_image_container
+      address = configuration.base_image || DEFAULT_BUILD_IMAGE
+      client.container(image_options).from(address)
+    end
+
+    def runtime_image_container
+      address = configuration.base_image || DEFAULT_RUNTIME_IMAGE
+      client.container(image_options).from(address)
+    end
+
+    def build_environment
+      BUNDLE_ENVIRONMENT
+        .merge(project.runtime_environment)
+        .merge("SECRET_KEY_BASE_DUMMY" => "1")
+        .merge(configuration.build_environment)
+    end
+
+    def runtime_environment
+      BUNDLE_ENVIRONMENT.merge(project.runtime_environment)
+    end
+
+    def with_environment(container, environment)
+      environment.reduce(container) do |result, (name, value)|
+        result.with_env_variable(name, value)
+      end
+    end
+
+    def install_toolchain(container)
+      toolchain = Mise.new(project, pipeline)
+      container = toolchain.with_project_metadata(container, at: application_path)
+      toolchain.install(container, tools: { ruby: project.ruby_version }, workdir: application_path, only: :ruby)
+    end
+
+    def install_gems(container)
+      container = BUNDLE_FILES.reduce(container.with_workdir(application_path)) do |result, name|
+        path = project.root.join(name)
+        path.file? ? result.with_file("#{application_path}/#{name}", project.source_file(client, name)) : result
+      end
+      container = pipeline.run(
+        container,
+        BUNDLE_INSTALL_COMMAND,
+        cache: "bundle",
+        at: "/usr/local/bundle/cache",
+        entry: "bundler",
+        name: "Install gems"
+      )
+      container.with_exec(["find", "/usr/local/bundle", "-path", "*/cache/*.gem", "-type", "f", "-delete"])
+               .with_exec([
+                            "sh", "-c",
+                            "find /usr/local/bundle -path '*/bundler/gems/*/.git' -type d -prune -exec rm -rf '{}' +"
+                          ])
+    end
+
+    def write_bundle_config(container)
+      container.with_workdir(application_path)
+               .with_exec(%w[mkdir -p .bundle])
+               .with_new_file("#{application_path}/.bundle/config", BUNDLE_CONFIG)
+    end
+
+    def pipeline
+      @pipeline ||= Pipeline.new(project, client, progress: progress)
+    end
+
+    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 = runtime_metadata(container).with_user(project.application_user)
+      progress.step("Assemble runtime 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])
+    end
+
+    def create_application_user(container)
+      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"])
+    end
+
+    def precompile(container)
+      container = container.with_exec(%w[bin/rails assets:precompile]) if project.rails? && project.assets?
+      if project.bootsnap?
+        paths = project.rails? ? %w[app/ lib/] : %w[app/ lib/ config/]
+        container = container.with_exec(["bundle", "exec", "bootsnap", "precompile", "--gemfile", *paths])
+      end
+      return container unless project.rails?
+
+      normalize_rails_output(container)
+    end
+
+    def normalize_rails_output(container)
+      ruby = <<~RUBY.strip
+        path = "public/assets/.manifest.json"
+        if File.file?(path)
+          manifest = JSON.parse(File.binread(path))
+          File.binwrite(path, JSON.generate(manifest.sort.to_h))
+        end
+      RUBY
+      container
+        .with_exec(["ruby", "-rjson", "-e", ruby])
+        .with_exec(%w[rm -f tmp/local_secret.txt tmp/cache/bootsnap/load-path-cache])
+    end
+
+    def runtime_metadata(container)
+      entrypoint = project.runtime_entrypoint
+      command = project.runtime_command
+      container = container.with_entrypoint(entrypoint) unless entrypoint.empty?
+      container = container.with_default_args(command) unless command.empty?
+      return container unless project.web?
+
+      port = project.runtime_port
+      container = container.with_exposed_port(port, description: "Ruby HTTP server")
+      return container unless project.rails?
+
+      container.with_docker_healthcheck(
+        ["curl", "--fail", "--silent", "http://localhost:#{port}/up"],
+        interval: "30s",
+        timeout: "5s",
+        retries: 3
+      )
+    end
+  end
+end

data/lib/boringbuilder/runtime.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module BoringBuilder
+  class Runtime
+    Probe = Data.define(:success, :message) do
+      alias_method :success?, :success
+    end
+    RUNTIME_COMMANDS = {
+      apple: %w[container system status],
+      docker: %w[docker version]
+    }.freeze
+
+    attr_reader :requested
+
+    def initialize(requested, probe: nil, host_os: RUBY_PLATFORM)
+      @requested = requested.to_sym
+      @probe = probe || method(:probe_command)
+      @host_os = host_os
+    end
+
+    def resolve
+      return session_runtime if dagger_session?
+      return :custom if custom_runner?
+      return ensure_available!(requested) unless requested == :auto
+
+      failures = []
+      runtime_order.each do |runtime|
+        result = @probe.call(runtime, RUNTIME_COMMANDS.fetch(runtime))
+        return runtime if result.success?
+
+        failures << "#{runtime}: #{result.message}"
+      end
+
+      raise BoringBuilder::RuntimeError, <<~MESSAGE.strip
+        No supported container runtime is ready. Start Apple Container with `container system start`
+        or start Docker, then try again. Probes: #{failures.join('; ')}
+      MESSAGE
+    end
+
+    def dagger_runtime(resolved = resolve)
+      %i[session custom].include?(resolved) ? :auto : resolved
+    end
+
+    private
+
+    def ensure_available!(runtime)
+      result = @probe.call(runtime, RUNTIME_COMMANDS.fetch(runtime))
+      return runtime if result.success?
+
+      hint = runtime == :apple ? "container system start" : "start the Docker daemon"
+      raise BoringBuilder::RuntimeError,
+            "#{runtime.to_s.capitalize} runtime is not ready: #{result.message}. Try `#{hint}`."
+    end
+
+    def runtime_order
+      @host_os.include?("darwin") ? %i[apple docker] : %i[docker apple]
+    end
+
+    def dagger_session?
+      ENV.fetch("DAGGER_SESSION_PORT", nil) && ENV.fetch("DAGGER_SESSION_TOKEN", nil)
+    end
+
+    def custom_runner?
+      ENV.fetch("_EXPERIMENTAL_DAGGER_RUNNER_HOST", nil) && requested == :auto
+    end
+
+    def session_runtime
+      runner_host = ENV.fetch("_EXPERIMENTAL_DAGGER_RUNNER_HOST", nil)
+      match = runner_host&.match(%r{\Aimage\+(apple|docker)://})
+      return match[1].to_sym if match
+      return :custom if runner_host
+
+      :session
+    end
+
+    def probe_command(_runtime, command)
+      stdout, stderr, status = Timeout.timeout(5) { Open3.capture3(*command) }
+      message = [stderr, stdout].map(&:strip).reject(&:empty?).first || "command exited #{status.exitstatus}"
+      Probe.new(success: status.success?, message: message)
+    rescue Errno::ENOENT
+      Probe.new(success: false, message: "#{command.first} is not installed")
+    rescue Timeout::Error
+      Probe.new(success: false, message: "probe timed out")
+    end
+  end
+end

data/lib/boringbuilder/tasks/boringbuilder.rake

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+namespace :boringbuilder do
+  desc "Build the Rails application with Dagger"
+  task build: :environment do
+    options = {}
+    {
+      runtime: "BORINGBUILDER_RUNTIME",
+      platform: "BORINGBUILDER_PLATFORM",
+      format: "BORINGBUILDER_FORMAT",
+      output: "BORINGBUILDER_OUTPUT",
+      publish: "BORINGBUILDER_PUSH",
+      load: "BORINGBUILDER_LOAD"
+    }.each do |option, environment_name|
+      value = ENV.fetch(environment_name, nil)
+      options[option] = value if value && !value.empty?
+    end
+
+    {
+      paths: "BORINGBUILDER_PATHS",
+      files: "BORINGBUILDER_FILES",
+      host_paths: "BORINGBUILDER_HOST_PATHS"
+    }.each do |option, environment_name|
+      values = ENV.fetch(environment_name, "").split(",").reject(&:empty?)
+      options[option] = values unless values.empty?
+    end
+
+    result = BoringBuilder.build(root: Rails.root, **options)
+    puts "Built with Dagger on #{result.runtime}"
+    puts "Exported #{result.format}: #{result.path}" if result.exported?
+    puts "Image: #{result.reference}" if result.published?
+  end
+
+  desc "Check the configured container runtime"
+  task :doctor do
+    requested = ENV.fetch("BORINGBUILDER_RUNTIME", "auto")
+    runtime = BoringBuilder::Runtime.new(requested).resolve
+    puts "Dagger runtime ready: #{runtime}"
+  end
+end

data/lib/boringbuilder/version.rb

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

data/lib/boringbuilder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+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"
+require_relative "boringbuilder/runtime"
+require_relative "boringbuilder/ruby_application"
+require_relative "boringbuilder/project"
+require_relative "boringbuilder/exporters"
+require_relative "boringbuilder/project_plan"
+require_relative "boringbuilder/ruby_build"
+require_relative "boringbuilder/rails_build"
+require_relative "boringbuilder/exporter"
+require_relative "boringbuilder/result"
+require_relative "boringbuilder/builder"
+require_relative "boringbuilder/cli"
+require_relative "boringbuilder/railtie" if defined?(Rails::Railtie)
+
+module BoringBuilder
+  class << self
+    def configure(&)
+      ConfigFile.configure(&)
+    end
+
+    def configuration(root: Dir.pwd, config: :auto, **options)
+      configuration = Configuration.new(root: root)
+      config_path = ConfigFile.resolve(configuration.root, config)
+      ConfigFile.load(config_path, configuration) if config_path
+      configuration.apply(options)
+    end
+
+    def build(root: Dir.pwd, config: :auto, **)
+      configuration = configuration(root: root, config: config, **)
+      yield configuration if block_given?
+      Builder.new(configuration).build
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: boringbuilder
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha.1
+platform: ruby
+authors:
+- BoringCache
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dagger_ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: BoringBuilder turns application source into filesystem artifacts and
+  container images. Rails is first class, while Mise-powered Dagger Ruby recipes support
+  any workload.
+email:
+- oss@boringcache.com
+executables:
+- boringbuilder
+extensions: []
+extra_rdoc_files: []
+files:
+- AGENTS.md
+- CHANGELOG.md
+- LICENSE
+- README.md
+- SECURITY.md
+- SOUL.md
+- STYLE.md
+- docs/artifacts.md
+- docs/building.md
+- docs/caching.md
+- exe/boringbuilder
+- 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
+- lib/boringbuilder/configuration.rb
+- lib/boringbuilder/errors.rb
+- lib/boringbuilder/exporter.rb
+- lib/boringbuilder/exporters.rb
+- lib/boringbuilder/exporters/asset.rb
+- lib/boringbuilder/exporters/boring_cache.rb
+- lib/boringbuilder/exporters/local.rb
+- lib/boringbuilder/exporters/receipt.rb
+- lib/boringbuilder/exporters/resolver.rb
+- lib/boringbuilder/initializer.rb
+- lib/boringbuilder/mise.rb
+- lib/boringbuilder/pipeline.rb
+- lib/boringbuilder/project.rb
+- lib/boringbuilder/project_plan.rb
+- lib/boringbuilder/rails_build.rb
+- lib/boringbuilder/railtie.rb
+- lib/boringbuilder/result.rb
+- lib/boringbuilder/ruby_application.rb
+- lib/boringbuilder/ruby_build.rb
+- lib/boringbuilder/runtime.rb
+- lib/boringbuilder/tasks/boringbuilder.rake
+- lib/boringbuilder/version.rb
+homepage: https://github.com/boringcache/builder
+licenses:
+- MIT
+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
+  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
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Build deployment artifacts and images with Dagger
+test_files: []