boringbuilder 0.1.0.alpha.1

data/lib/boringbuilder/configuration.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module BoringBuilder
+  class Configuration
+    FORMATS = %i[directory tar tar_zst oci docker].freeze
+    RUNTIMES = %i[auto apple docker].freeze
+    FORMAT_ALIASES = {
+      "tar.zst" => :tar_zst,
+      "tar-zst" => :tar_zst,
+      "tar_zst" => :tar_zst
+    }.freeze
+
+    attr_accessor :root, :runtime, :platform, :format, :output,
+                  :base_image, :paths, :files, :host_paths, :publish, :load,
+                  :progress, :assets, :bootsnap, :artifact,
+                  :command, :port, :exporter, :artifact_name,
+                  :build_packages, :runtime_packages, :build_environment
+    attr_writer :pipeline
+
+    def initialize(root: Dir.pwd, runtime: :auto, platform: nil, format: :tar_zst,
+                   output: nil, base_image: nil, paths: nil,
+                   files: nil, host_paths: nil, publish: nil, load: nil,
+                   progress: nil, assets: nil, bootsnap: nil,
+                   artifact: nil, command: nil, port: nil,
+                   exporter: :auto, artifact_name: nil, pipeline: nil,
+                   build_packages: nil, runtime_packages: nil, build_environment: nil)
+      @root = Pathname.new(root).expand_path
+      @runtime = normalize_runtime(runtime)
+      @platform = platform
+      @format = normalize_format(format)
+      @output = output && Pathname.new(output).expand_path(@root)
+      @base_image = base_image
+      @paths = Array(paths).compact
+      @files = Array(files).compact
+      @host_paths = Array(host_paths).compact
+      @publish = publish
+      @load = load
+      @progress = progress
+      @assets = assets
+      @bootsnap = bootsnap
+      @artifact = artifact || Artifact.new(root: @root)
+      @command = command
+      @port = port
+      @exporter = normalize_exporter(exporter)
+      @artifact_name = artifact_name
+      @pipeline = pipeline
+      @build_packages = normalize_packages(build_packages)
+      @runtime_packages = normalize_packages(runtime_packages)
+      @build_environment = normalize_environment(build_environment)
+    end
+
+    def validate!
+      normalize!
+      validate_project_directory!
+      validate_option_combinations!
+      validate_port!
+      validate_artifact!
+      validate_output_path!
+      self
+    end
+
+    def apply(options)
+      options.each do |name, value|
+        writer = "#{name}="
+        raise ConfigurationError, "Unknown configuration option: #{name}" unless respond_to?(writer)
+
+        public_send(writer, value)
+      end
+      self
+    end
+
+    def pipeline(&block)
+      @pipeline = block if block
+      @pipeline
+    end
+
+    private
+
+    def validate_project_directory!
+      raise ConfigurationError, "Project directory does not exist: #{root}" unless root.directory?
+    end
+
+    def validate_option_combinations!
+      raise ConfigurationError, "--push and --load cannot be used together" if publish && load
+    end
+
+    def validate_port!
+      raise ConfigurationError, "port must be a positive integer" if port && port <= 0
+    end
+
+    def validate_artifact!
+      raise ConfigurationError, "artifact must be a BoringBuilder::Artifact" unless artifact.is_a?(Artifact)
+      raise ConfigurationError, "pipeline must be callable" if pipeline && !pipeline.respond_to?(:call)
+    end
+
+    def normalize!
+      @root = Pathname.new(root).expand_path
+      @runtime = normalize_runtime(runtime)
+      @format = normalize_format(format)
+      @output = output && Pathname.new(output).expand_path(root)
+      normalize_collection_options!
+      normalize_build_options!
+    end
+
+    def normalize_collection_options!
+      @paths = Array(paths).compact
+      @files = Array(files).compact
+      @host_paths = Array(host_paths).compact
+    end
+
+    def normalize_build_options!
+      @port = normalize_port(port) if port
+      @exporter = normalize_exporter(exporter)
+      @artifact_name = artifact_name&.to_s
+      @build_packages = normalize_packages(build_packages)
+      @runtime_packages = normalize_packages(runtime_packages)
+      @build_environment = normalize_environment(build_environment)
+    end
+
+    def normalize_runtime(value)
+      runtime = value.to_s.downcase.to_sym
+      return runtime if RUNTIMES.include?(runtime)
+
+      raise ConfigurationError, "Unknown runtime '#{value}'. Use auto, apple, or docker."
+    end
+
+    def normalize_format(value)
+      format = FORMAT_ALIASES.fetch(value.to_s, value.to_s.downcase.to_sym)
+      return format if FORMATS.include?(format)
+
+      raise ConfigurationError, "Unknown format '#{value}'. Use directory, tar, tar.zst, oci, or docker."
+    end
+
+    def normalize_port(value)
+      Integer(value)
+    rescue ArgumentError, TypeError
+      raise ConfigurationError, "port must be a positive integer"
+    end
+
+    def normalize_exporter(value)
+      exporter = (value || :auto).to_sym
+      return exporter if %i[auto local boringcache].include?(exporter)
+
+      raise ConfigurationError, "exporter must be auto, local, or boringcache"
+    end
+
+    def normalize_packages(packages)
+      Array(packages).compact.map(&:to_s)
+    end
+
+    def normalize_environment(environment)
+      (environment || {}).to_h { |name, value| [name.to_s, value.to_s] }
+    end
+
+    def validate_output_path!
+      return unless output
+
+      unsafe = output == Pathname.new("/") || output == root || output == Pathname.new(Dir.home).expand_path
+      unsafe ||= format == :directory && root.to_s.start_with?("#{output}/")
+      raise ConfigurationError, "Refusing unsafe output path: #{output}" if unsafe
+    end
+  end
+end

data/lib/boringbuilder/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class RuntimeError < Error; end
+  class BuildError < Error; end
+  class ExportError < Error; end
+end

data/lib/boringbuilder/exporter.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tmpdir"
+
+module BoringBuilder
+  class Exporter
+    PACKER_IMAGE = "alpine:3.22@sha256:14358309a308569c32bdc37e2e0e9694be33a9d99e68afb0f5ff33cc1f695dce"
+
+    attr_reader :project, :client, :container, :runtime, :exporters, :progress
+
+    def initialize(project, client, container, runtime:, command_runner: nil, exporters: nil,
+                   progress: BuildProgress.silent)
+      @project = project
+      @client = client
+      @container = container
+      @runtime = runtime
+      @command_runner = command_runner || ->(*command) { Open3.capture3(*command) }
+      @exporters = exporters || Exporters::Resolver.new(project, client).destinations
+      @progress = progress
+    end
+
+    def call
+      exporters.each(&:validate!)
+      asset = build_asset unless exporters.empty?
+      receipt = exporters.reduce(Exporters::Receipt.new) do |result, adapter|
+        received = progress.step(export_step_name(adapter)) { adapter.export(asset) }
+        merge_receipts(result, received)
+      end
+      reference = export_reference
+      Result.new(
+        format: configuration.format,
+        path: receipt.path,
+        reference: reference,
+        runtime: runtime,
+        platform: configuration.platform,
+        artifact_id: receipt.artifact_id,
+        artifact_name: receipt.artifact_name
+      )
+    rescue DaggerRuby::DaggerError => e
+      raise ExportError, "Dagger could not export the build: #{e.message}"
+    end
+
+    private
+
+    def configuration
+      project.configuration
+    end
+
+    def merge_receipts(current, received)
+      Exporters::Receipt.new(
+        path: received.path || current.path,
+        artifact_id: received.artifact_id || current.artifact_id,
+        artifact_name: received.artifact_name || current.artifact_name
+      )
+    end
+
+    def export_step_name(adapter)
+      return "Publish artifact to BoringCache" if adapter.name == :boringcache
+
+      "Export #{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)
+      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)
+      end
+    end
+
+    def export_reference
+      if configuration.publish
+        progress.step("Publish container image") do
+          container.publish(configuration.publish, media_types: media_types)
+        end
+      elsif configuration.load
+        progress.step("Load container image") { load_image }
+      end
+    end
+
+    def load_image
+      return load_apple_image if runtime == :apple
+
+      container.export_image(configuration.load, media_types: media_types)
+      configuration.load
+    end
+
+    def load_apple_image
+      Dir.mktmpdir("boringbuilder-load") do |directory|
+        archive = File.join(directory, "image.oci.tar")
+        container.export(archive, media_types: :OCIMediaTypes)
+        source = load_apple_archive(archive)
+        run_apple_command("container", "image", "tag", source, configuration.load)
+      end
+      configuration.load
+    end
+
+    def load_apple_archive(archive)
+      output = run_apple_command("container", "image", "load", "--input", archive)
+      source = output[/\b(?:untagged@)?sha256:[0-9a-f]{64}\b/]
+      return source if source
+
+      raise ExportError, "Apple Container loaded the image without returning a taggable digest"
+    end
+
+    def run_apple_command(*command)
+      stdout, stderr, status = @command_runner.call(*command)
+      output = [stdout, stderr].map(&:strip).reject(&:empty?).join("\n")
+      return output if status.success?
+
+      raise ExportError, "#{command.first(3).join(' ')} failed: #{output}"
+    end
+
+    def artifact_directory
+      @artifact_directory ||= project.artifact.export_directory(client, container)
+    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)
+      tar_path = compression == :zstd ? "/artifact.tar" : "/#{filename}"
+      packer = packer.with_exec(
+        [
+          "tar", "--sort=name", "--mtime=@0", "--owner=0", "--group=0", "--numeric-owner",
+          "--pax-option=delete=atime,delete=ctime", "-C", "/artifact", "-cf", tar_path, "."
+        ]
+      )
+      packer = packer.with_exec(["zstd", "-q", "-T1", tar_path, "-o", "/#{filename}"]) if compression == :zstd
+      packer.file("/#{filename}")
+    end
+
+    def media_types
+      configuration.format == :docker ? :DockerMediaTypes : :OCIMediaTypes
+    end
+  end
+end

data/lib/boringbuilder/exporters/asset.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  module Exporters
+    Asset = Data.define(:kind, :source, :filename)
+  end
+end

data/lib/boringbuilder/exporters/boring_cache.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+
+module BoringBuilder
+  module Exporters
+    class BoringCache
+      attr_reader :project, :client, :cache
+
+      def initialize(project, client, environment: ENV)
+        @project = project
+        @client = client
+        @cache = ::BoringBuilder::BoringCache.new(project, client, environment: environment)
+      end
+
+      def name = :boringcache
+
+      def validate!
+        if configuration.artifact_name&.strip == ""
+          raise ConfigurationError, "BoringCache Artifact name cannot be empty"
+        end
+        raise ConfigurationError, "The boringcache exporter requires BORINGCACHE_SAVE_TOKEN" unless cache.save_token?
+        return self if cache.workspace_configured?
+
+        raise ConfigurationError,
+              "The boringcache exporter requires a workspace environment variable or .boringcache.toml"
+      end
+
+      def export(asset)
+        validate!
+        publisher = client.container.from(cache.cli_image)
+        publisher = cache.prepare_artifact_publisher(publisher)
+        path, publisher = mount_asset(publisher, asset)
+        output = publisher.with_exec(publish_command(path, asset.kind)).stdout
+        artifact = JSON.parse(output).fetch("artifact")
+        validate_artifact!(artifact)
+        Receipt.new(artifact_id: artifact.fetch("id"), artifact_name: artifact.fetch("name"))
+      rescue JSON::ParserError, KeyError => e
+        raise ExportError, "BoringCache Artifact returned an invalid receipt: #{e.message}"
+      end
+
+      private
+
+      def configuration
+        project.configuration
+      end
+
+      def artifact_name
+        configuration.artifact_name || [project.app_name, platform_name, format_name].join("-")
+      end
+
+      def platform_name
+        (configuration.platform || "native").tr("/", "-")
+      end
+
+      def format_name
+        configuration.format.to_s.tr("_", "-")
+      end
+
+      def mount_asset(publisher, asset)
+        if asset.kind == :directory
+          ["/artifact", publisher.with_mounted_directory("/artifact", asset.source)]
+        else
+          path = "/artifact/#{asset.filename}"
+          [path, publisher.with_file(path, asset.source)]
+        end
+      end
+
+      def publish_command(path, kind)
+        command = ["boringcache", "artifact", "push", path, "--name", artifact_name,
+                   "--include-hidden", "--json"]
+        command.push("--compression", "none") unless kind == :directory
+        command
+      end
+
+      def validate_artifact!(artifact)
+        return if artifact.fetch("id", "").start_with?("art_") && artifact.fetch("status", nil) == "ready"
+
+        raise ExportError, "BoringCache Artifact did not return a ready artifact"
+      end
+    end
+  end
+end

data/lib/boringbuilder/exporters/local.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module BoringBuilder
+  module Exporters
+    class Local
+      attr_reader :project
+
+      def initialize(project)
+        @project = project
+      end
+
+      def name = :local
+
+      def validate! = self
+
+      def export(asset)
+        output = project.output_path
+        FileUtils.mkdir_p(output.dirname)
+        options = asset.kind == :directory ? { wipe: true } : {}
+        asset.source.export(output.to_s, **options)
+        Receipt.new(path: output.to_s)
+      end
+    end
+  end
+end

data/lib/boringbuilder/exporters/receipt.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  module Exporters
+    Receipt = Data.define(:path, :artifact_id, :artifact_name) do
+      def initialize(path: nil, artifact_id: nil, artifact_name: nil)
+        super
+      end
+    end
+  end
+end

data/lib/boringbuilder/exporters/resolver.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  module Exporters
+    class Resolver
+      ADAPTERS = {
+        local: Local,
+        boringcache: BoringCache
+      }.freeze
+
+      attr_reader :project, :client, :cache
+
+      def initialize(project, client, environment: ENV)
+        @project = project
+        @client = client
+        @environment = environment
+        @cache = ::BoringBuilder::BoringCache.new(project, client, environment: environment)
+      end
+
+      def destinations
+        names = [primary_name].compact
+        names << :local if configuration.output && !names.include?(:local)
+        names.map { |name| adapter(name) }
+      end
+
+      def plan
+        destinations.map(&:name)
+      end
+
+      def validate!
+        destinations.each(&:validate!)
+        self
+      end
+
+      private
+
+      def configuration
+        project.configuration
+      end
+
+      def primary_name
+        return configuration.exporter unless configuration.exporter == :auto
+        return :boringcache if cache.artifact_publishable?
+        return if configuration.publish || configuration.load
+
+        :local
+      end
+
+      def adapter(name)
+        adapter = ADAPTERS.fetch(name)
+        return adapter.new(project) if name == :local
+
+        adapter.new(project, client, environment: @environment)
+      end
+    end
+  end
+end

data/lib/boringbuilder/exporters.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "exporters/asset"
+require_relative "exporters/receipt"
+require_relative "exporters/local"
+require_relative "exporters/boring_cache"
+require_relative "exporters/resolver"

data/lib/boringbuilder/initializer.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module BoringBuilder
+  class Initializer
+    TEMPLATES = %i[auto ruby node rust go generic].freeze
+
+    attr_reader :root, :requested_template
+
+    def initialize(root, template: :auto)
+      @root = Pathname.new(root).expand_path
+      @requested_template = template.to_s.downcase.to_sym
+    end
+
+    def call(force: false)
+      validate!
+      raise ConfigurationError, "#{path} already exists; pass --force to replace it" if path.exist? && !force
+
+      FileUtils.mkdir_p(path.dirname)
+      path.write(template)
+      path
+    end
+
+    def template_name
+      return requested_template unless requested_template == :auto
+      return :ruby if root.join("Gemfile").file?
+      return :node if root.join("package.json").file?
+      return :rust if root.join("Cargo.toml").file?
+      return :go if root.join("go.mod").file?
+
+      :generic
+    end
+
+    private
+
+    def path
+      root.join(ConfigFile::DEFAULT_PATH)
+    end
+
+    def validate!
+      raise ConfigurationError, "Project directory does not exist: #{root}" unless root.directory?
+      return if TEMPLATES.include?(requested_template)
+
+      raise ConfigurationError, "Unknown template '#{requested_template}'. Use auto, ruby, node, rust, go, or generic."
+    end
+
+    def template
+      send("#{template_name}_template")
+    end
+
+    def ruby_template
+      <<~RUBY
+        # frozen_string_literal: true
+
+        # Rails, Hanami, Rack, and other Bundler applications use BoringBuilder's
+        # built-in Mise-powered pipeline. Add only the application-specific choices.
+        BoringBuilder.configure do |config|
+          # config.build_packages += %w[libexample-dev]
+          # config.runtime_packages += %w[libexample1]
+        end
+      RUBY
+    end
+
+    def node_template
+      install = root.join("package-lock.json").file? ? "%w[npm ci]" : "%w[npm install]"
+      build = node_build?
+      artifact = if build
+                   'config.artifact.directory("/app/dist", at: "/app")'
+                 else
+                   'config.artifact.directory("/app")'
+                 end
+      build_step = if build
+                     "\n    pipeline.exec(app, %w[npm run build], name: \"Build application\")"
+                   else
+                     "\n    app"
+                   end
+
+      <<~RUBY
+        # frozen_string_literal: true
+
+        BoringBuilder.configure do |config|
+          #{artifact}
+
+          config.pipeline do |pipeline|
+            app = pipeline.mise(tools: { node: "24" }, workdir: "/app")
+
+            app = pipeline.run(
+              app,
+              #{install},
+              cache: "npm-downloads",
+              at: "/root/.npm/_cacache",
+              workdir: "/app",
+              name: "Install dependencies"
+            )
+        #{build_step}
+          end
+        end
+      RUBY
+    end
+
+    def rust_template
+      <<~RUBY
+        # frozen_string_literal: true
+
+        BoringBuilder.configure do |config|
+          config.artifact.directory("/app/target/release", at: "/app")
+
+          config.pipeline do |pipeline|
+            app = pipeline.mise(tools: { rust: "stable" }, workdir: "/app")
+
+            pipeline.run(
+              app,
+              %w[cargo build --release],
+              cache: {
+                "cargo-registry" => "/root/.cargo/registry",
+                "cargo-git" => "/root/.cargo/git"
+              },
+              workdir: "/app",
+              name: "Build application"
+            )
+          end
+        end
+      RUBY
+    end
+
+    def go_template
+      <<~RUBY
+        # frozen_string_literal: true
+
+        BoringBuilder.configure do |config|
+          config.artifact.directory("/app/dist", at: "/app")
+
+          config.pipeline do |pipeline|
+            app = pipeline.mise(tools: { go: "1" }, workdir: "/app")
+
+            pipeline.run(
+              app,
+              %w[go build -o /app/dist/app .],
+              cache: {
+                "go-modules" => "/root/go/pkg/mod",
+                "go-build" => "/root/.cache/go-build"
+              },
+              workdir: "/app",
+              name: "Build application"
+            )
+          end
+        end
+      RUBY
+    end
+
+    def generic_template
+      <<~RUBY
+        # frozen_string_literal: true
+
+        BoringBuilder.configure do |config|
+          config.artifact.directory("/app")
+
+          config.pipeline do |pipeline|
+            # Add only the tools the application needs, then its build steps.
+            pipeline.mise(
+              tools: {
+                # "python" => "3"
+              },
+              workdir: "/app"
+            )
+          end
+        end
+      RUBY
+    end
+
+    def node_build?
+      scripts = JSON.parse(root.join("package.json").read)["scripts"]
+      scripts.is_a?(Hash) && scripts.key?("build")
+    rescue JSON::ParserError, TypeError
+      false
+    end
+  end
+end