prebake 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dab6849310807672ec24350dbd6343e3adb1875ffd5a84912d3279fcdf4a455d
+  data.tar.gz: be4d4d24fee4c87d755eaa85175204772a10e2ba0a1c81047b342f6593a4cab2
+SHA512:
+  metadata.gz: 1cd47249386725f821a1c9e497c1fc5a9c27aa872255a0b745147d96a697f69ca9a648171aa13067c40fe3994882d81cab31cb73a063e7928de88e59c624d4d3
+  data.tar.gz: 7997b12e900e9122114ea31539e4e8a448ca898fe4e559abbb4957baa7634277d50e24aa731021eb73c659e66ff39f84f49180c312bd1dceadf445297bf1ab93

data/lib/prebake/async_publisher.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "platform_gem_builder"
+require_relative "cache_key"
+require_relative "platform"
+require_relative "logger"
+
+module Prebake
+  module AsyncPublisher
+    @pending_specs = []
+    @threads = []
+    @mutex = Mutex.new
+
+    def self.reset!
+      @mutex.synchronize do
+        @pending_specs.clear
+        @threads.clear
+      end
+    end
+
+    # Queue a spec for later processing (no threads, no chdir)
+    def self.enqueue(spec, backend)
+      @mutex.synchronize { @pending_specs << [spec, backend] }
+    end
+
+    # For testing - enqueue a raw block for async execution
+    def self.enqueue_block(&block)
+      thread = Thread.new do
+        block.call
+      rescue StandardError => e
+        Logger.warn "Error in background task: #{e.message}"
+      end
+
+      @mutex.synchronize { @threads << thread }
+    end
+
+    # Build all queued gems (serial, safe for Dir.chdir) then push in parallel
+    def self.wait_for_completion(timeout: 120)
+      # First, wait for any raw block threads (from tests)
+      block_threads = @mutex.synchronize { @threads.dup }
+      block_threads.each { |t| t.join(timeout) }
+
+      # Then process queued specs
+      specs = @mutex.synchronize { @pending_specs.dup }
+      return if specs.empty?
+
+      Logger.info "Building #{specs.size} platform gem(s)..."
+
+      # Build serially (Dir.chdir is not thread-safe in Ruby 4.0)
+      built_gems = specs.filter_map do |spec, backend|
+        build_gem(spec, backend)
+      end
+
+      if built_gems.any?
+        Logger.info "Pushing #{built_gems.size} gem(s) in background..."
+
+        # Push in parallel (just HTTP, no chdir needed)
+        push_threads = built_gems.map do |gem_path, cache_key, checksum, backend|
+          Thread.new do
+            backend.push(gem_path, cache_key, checksum)
+          rescue StandardError => e
+            Logger.warn "Push failed for #{cache_key}: #{e.message}"
+          ensure
+            FileUtils.rm_f(gem_path)
+          end
+        end
+
+        push_threads.each { |t| t.join(timeout) }
+      end
+
+      Logger.info "All pushes complete."
+
+      @mutex.synchronize do
+        @pending_specs.clear
+        @threads.clear
+      end
+    end
+
+    def self.build_gem(spec, backend)
+      platform = Platform.generalized
+      cache_key = CacheKey.for(spec.name, spec.version.to_s, platform)
+
+      if backend.exists?(cache_key)
+        Logger.debug "#{cache_key} already cached, skipping"
+        return nil
+      end
+
+      builder = PlatformGemBuilder.new(spec)
+      gem_path = builder.build
+      checksum = builder.checksum
+
+      Logger.debug "Built #{cache_key}"
+      [gem_path, cache_key, checksum, backend]
+    rescue StandardError => e
+      Logger.warn "Error building #{spec.name}: #{e.message}"
+      nil
+    end
+
+    private_class_method :build_gem
+  end
+end

data/lib/prebake/backends/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Prebake
+  module Backends
+    class Base
+      def fetch(cache_key)
+        raise NotImplementedError, "#{self.class}#fetch not implemented"
+      end
+
+      def fetch_checksum(cache_key)
+        raise NotImplementedError, "#{self.class}#fetch_checksum not implemented"
+      end
+
+      def push(gem_path, cache_key, checksum)
+        raise NotImplementedError, "#{self.class}#push not implemented"
+      end
+
+      def exists?(cache_key)
+        raise NotImplementedError, "#{self.class}#exists? not implemented"
+      end
+    end
+  end
+end

data/lib/prebake/backends/gemstash.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "uri"
+require "securerandom"
+require_relative "base"
+require_relative "http_client"
+require_relative "../logger"
+
+module Prebake
+  module Backends
+    class Gemstash < Base
+      include HttpClient
+
+      # Gemstash serves private gems at /private/gems/{name}-{version}-{platform}.gem
+      # based on the gem's internal metadata. Our cache key includes the Ruby ABI
+      # (e.g., puma-6.4.3-arm64-darwin-ruby4.0.gem) which Gemstash doesn't know about.
+      #
+      # To make this work, we encode the Ruby ABI into the gem version when building:
+      # puma version 6.4.3 becomes 6.4.3.pre.ruby40 in the Gemstash-stored gem.
+      # Gemstash then serves it at /private/gems/puma-6.4.3.pre.ruby40-arm64-darwin.gem
+      #
+      # The push endpoint is POST /api/v1/gems (standard RubyGems push).
+      # The fetch endpoint is GET /private/gems/{gem_filename}.
+      # Auth is via Authorization header with the Gemstash API key.
+
+      def initialize(url:, key: nil)
+        @url = url.chomp("/")
+        @key = key
+
+        return if @url.start_with?("https://") || ENV.fetch("PREBAKE_ALLOW_INSECURE", "false") == "true"
+        return unless @url.start_with?("http://")
+
+        Logger.warn(
+          "Using insecure HTTP connection to #{@url}. " \
+          "Set PREBAKE_ALLOW_INSECURE=true to suppress this warning."
+        )
+      end
+
+      def fetch(cache_key)
+        gem_filename = gemstash_filename(cache_key)
+        uri = URI("#{@url}/private/gems/#{gem_filename}")
+        response = http_request(:get, uri)
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        path = File.join(Dir.tmpdir, "prebake-#{SecureRandom.hex(16)}.gem")
+        File.binwrite(path, response.body)
+        path
+      rescue StandardError => e
+        Logger.debug "Fetch failed for #{cache_key}: #{e.message}"
+        nil
+      end
+
+      def fetch_checksum(_cache_key)
+        # Gemstash doesn't store arbitrary files alongside gems.
+        # Checksum verification is skipped for Gemstash backend.
+        nil
+      end
+
+      def push(gem_path, cache_key, _checksum)
+        uri = URI("#{@url}/private/api/v1/gems")
+        gem_content = File.binread(gem_path)
+        response = http_request(:post, uri, body: gem_content)
+
+        case response
+        when Net::HTTPSuccess, Net::HTTPConflict
+          Logger.info "Pushed #{cache_key} to Gemstash"
+          true
+        else
+          Logger.warn "Failed to push #{cache_key}: #{response.code} #{response.message}"
+          false
+        end
+      rescue StandardError => e
+        Logger.warn "Push failed for #{cache_key}: #{e.message}"
+        false
+      end
+
+      def exists?(cache_key)
+        gem_filename = gemstash_filename(cache_key)
+        uri = URI("#{@url}/private/gems/#{gem_filename}")
+        response = http_request(:head, uri)
+        response.is_a?(Net::HTTPSuccess)
+      rescue StandardError
+        false
+      end
+
+      private
+
+      def apply_auth_header(request)
+        request["Authorization"] = @key if @key
+      end
+
+      def gemstash_filename(cache_key)
+        cache_key.sub(/-ruby\d+\.\d+(\.gem)/, '\1')
+      end
+    end
+  end
+end

data/lib/prebake/backends/http.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "uri"
+require "securerandom"
+require_relative "base"
+require_relative "http_client"
+require_relative "../logger"
+
+module Prebake
+  module Backends
+    class Http < Base
+      include HttpClient
+
+      def initialize(url:, token: nil)
+        @url = url.chomp("/")
+        @token = token
+
+        return if @url.start_with?("https://") || ENV.fetch("PREBAKE_ALLOW_INSECURE", "false") == "true"
+        return unless @url.start_with?("http://")
+
+        Logger.warn(
+          "Using insecure HTTP connection to #{@url}. " \
+          "Set PREBAKE_ALLOW_INSECURE=true to suppress this warning."
+        )
+      end
+
+      def fetch(cache_key)
+        uri = URI("#{@url}/gems/#{cache_key}")
+        response = http_request(:get, uri)
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        path = File.join(Dir.tmpdir, "prebake-#{SecureRandom.hex(16)}.gem")
+        File.binwrite(path, response.body)
+        path
+      rescue StandardError => e
+        Logger.debug "Fetch failed for #{cache_key}: #{e.message}"
+        nil
+      end
+
+      def fetch_checksum(cache_key)
+        uri = URI("#{@url}/gems/#{cache_key}.sha256")
+        response = http_request(:get, uri)
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        response.body.strip
+      rescue StandardError => e
+        Logger.debug "Checksum fetch failed for #{cache_key}: #{e.message}"
+        nil
+      end
+
+      def push(gem_path, cache_key, checksum)
+        gem_uri = URI("#{@url}/gems/#{cache_key}")
+        gem_response = http_request(:put, gem_uri, body: File.binread(gem_path))
+
+        unless gem_response.is_a?(Net::HTTPSuccess)
+          Logger.warn "Failed to push #{cache_key}: #{gem_response.code}"
+          return false
+        end
+
+        # Checksum is a secondary artifact - log failure but don't fail the push.
+        # The gem itself was pushed successfully; missing checksums can be backfilled.
+        checksum_uri = URI("#{@url}/gems/#{cache_key}.sha256")
+        checksum_response = http_request(:put, checksum_uri, body: checksum)
+
+        unless checksum_response.is_a?(Net::HTTPSuccess)
+          Logger.warn "Checksum push failed for #{cache_key}: #{checksum_response.code}"
+        end
+
+        Logger.info "Pushed #{cache_key}"
+        true
+      rescue StandardError => e
+        Logger.warn "Push failed for #{cache_key}: #{e.message}"
+        false
+      end
+
+      def exists?(cache_key)
+        uri = URI("#{@url}/gems/#{cache_key}")
+        response = http_request(:head, uri)
+        response.is_a?(Net::HTTPSuccess)
+      rescue StandardError
+        false
+      end
+
+      private
+
+      def apply_auth_header(request)
+        request["Authorization"] = "Bearer #{@token}" if @token
+      end
+    end
+  end
+end

data/lib/prebake/backends/http_client.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module Prebake
+  module Backends
+    module HttpClient
+      TIMEOUT = 30
+      HTTP_METHODS = { get: Net::HTTP::Get, head: Net::HTTP::Head,
+                       post: Net::HTTP::Post, put: Net::HTTP::Put }.freeze
+
+      private
+
+      def http_request(method, uri, body: nil)
+        request = build_http_request(method, uri)
+        if body
+          request["Content-Type"] = "application/octet-stream"
+          request.body = body
+        end
+
+        Net::HTTP.start(uri.host, uri.port,
+                        use_ssl: uri.scheme == "https",
+                        open_timeout: TIMEOUT,
+                        read_timeout: TIMEOUT) do |http|
+          http.request(request)
+        end
+      end
+
+      def build_http_request(method, uri)
+        request = HTTP_METHODS.fetch(method).new(uri)
+        apply_auth_header(request)
+        request
+      end
+
+      def apply_auth_header(request)
+        raise NotImplementedError, "#{self.class} must implement apply_auth_header"
+      end
+    end
+  end
+end

data/lib/prebake/backends/s3.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "securerandom"
+require_relative "base"
+require_relative "../logger"
+
+module Prebake
+  module Backends
+    class S3 < Base
+      def initialize(bucket:, region: "us-east-1", prefix: "prebake")
+        @bucket = bucket
+        @region = region
+        @prefix = prefix
+      end
+
+      def fetch(cache_key)
+        return nil unless sdk_available?
+
+        response = client.get_object(bucket: @bucket, key: object_key(cache_key))
+        path = File.join(Dir.tmpdir, "prebake-#{SecureRandom.hex(16)}.gem")
+        File.binwrite(path, response.body.read)
+        path
+      rescue StandardError => e
+        Logger.debug "S3 fetch failed for #{cache_key}: #{e.message}"
+        nil
+      end
+
+      def fetch_checksum(cache_key)
+        return nil unless sdk_available?
+
+        response = client.get_object(bucket: @bucket, key: "#{object_key(cache_key)}.sha256")
+        response.body.read.strip
+      rescue StandardError => e
+        Logger.debug "S3 checksum fetch failed for #{cache_key}: #{e.message}"
+        nil
+      end
+
+      def push(gem_path, cache_key, checksum)
+        return false unless sdk_available?
+
+        File.open(gem_path, "rb") do |file|
+          client.put_object(bucket: @bucket, key: object_key(cache_key), body: file)
+        end
+        client.put_object(bucket: @bucket, key: "#{object_key(cache_key)}.sha256", body: checksum)
+        Logger.info "Pushed #{cache_key} to S3"
+        true
+      rescue StandardError => e
+        Logger.warn "S3 push failed for #{cache_key}: #{e.message}"
+        false
+      end
+
+      def exists?(cache_key)
+        return false unless sdk_available?
+
+        client.head_object(bucket: @bucket, key: object_key(cache_key))
+        true
+      rescue StandardError
+        false
+      end
+
+      private
+
+      def object_key(cache_key)
+        "#{@prefix}/#{cache_key}"
+      end
+
+      def sdk_available?
+        require "aws-sdk-s3"
+        true
+      rescue LoadError
+        Logger.warn "aws-sdk-s3 not available. Install it to use S3 backend."
+        false
+      end
+
+      def client
+        @client ||= Aws::S3::Client.new(region: @region)
+      end
+    end
+  end
+end

data/lib/prebake/cache_key.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Prebake
+  module CacheKey
+    def self.for(name, version, platform)
+      "#{name}-#{version}-#{platform}-ruby#{Prebake::RUBY_ABI_VERSION}.gem"
+    end
+
+    def self.checksum_for(name, version, platform)
+      "#{self.for(name, version, platform)}.sha256"
+    end
+  end
+end

data/lib/prebake/ext_builder_patch.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "rubygems/ext"
+require "fileutils"
+require "digest"
+require_relative "cache_key"
+require_relative "platform"
+require_relative "extractor"
+require_relative "logger"
+
+module Prebake
+  module ExtBuilderPatch
+    def build_extensions
+      return super unless @spec.extensions.any?
+      return super unless Prebake.enabled?
+      return super unless Prebake.backend # nil if config failed
+
+      platform = Platform.generalized
+      cache_key = CacheKey.for(@spec.name, @spec.version.to_s, platform)
+
+      begin
+        cached_gem = Prebake.backend.fetch(cache_key)
+      rescue StandardError => e
+        Logger.debug "Cache fetch error for #{@spec.name}: #{e.message}"
+        return super
+      end
+
+      unless cached_gem
+        Logger.debug "Cache miss for #{cache_key}"
+        return super
+      end
+
+      # Verify checksum if available
+      if verify_checksum(cache_key, cached_gem)
+        install_from_cache(cached_gem)
+      else
+        Logger.warn "Checksum mismatch for #{cache_key}, compiling from source"
+        super
+      end
+    ensure
+      FileUtils.rm_f(cached_gem) if cached_gem && File.exist?(cached_gem.to_s)
+    end
+
+    private
+
+    def verify_checksum(cache_key, gem_path)
+      expected = Prebake.backend.fetch_checksum(cache_key)
+
+      if expected.nil?
+        if ENV.fetch("PREBAKE_REQUIRE_CHECKSUM", "false") == "true"
+          Logger.warn "No checksum available for #{cache_key} and PREBAKE_REQUIRE_CHECKSUM=true, rejecting"
+          return false
+        end
+        Logger.warn "No checksum available for #{cache_key}, skipping verification"
+        return true
+      end
+
+      actual = Digest::SHA256.file(gem_path).hexdigest
+      if actual == expected
+        true
+      else
+        Logger.warn "Checksum mismatch for #{cache_key}: expected #{expected}, got #{actual}"
+        false
+      end
+    end
+
+    def install_from_cache(gem_path)
+      Logger.info "Installing precompiled #{@spec.name}-#{@spec.version}"
+      Extractor.install(gem_path, @spec)
+      FileUtils.mkdir_p(File.dirname(@spec.gem_build_complete_path))
+      FileUtils.touch(@spec.gem_build_complete_path)
+    end
+  end
+end

data/lib/prebake/extractor.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "rubygems/package"
+require "fileutils"
+require_relative "logger"
+
+module Prebake
+  module Extractor
+    BINARY_EXTENSIONS = %w[.so .bundle .dll].freeze
+
+    def self.install(gem_path, spec)
+      Logger.debug "Extracting precompiled binaries from #{File.basename(gem_path)}"
+
+      extracted_count = 0
+
+      Dir.mktmpdir("prebake-extract") do |tmpdir|
+        # Extract all files from the gem into a temp directory
+        Gem::Package.new(gem_path).extract_files(tmpdir)
+
+        # Copy only binary files (.so, .bundle, .dll) to extension_dir
+        Dir.glob(File.join(tmpdir, "**/*.{so,bundle,dll}")).each do |binary|
+          # Reject symlinks
+          next if File.symlink?(binary)
+
+          # Verify path is within tmpdir (prevent traversal)
+          real_binary = File.realpath(binary)
+          real_tmpdir = File.realpath(tmpdir)
+          next unless real_binary.start_with?("#{real_tmpdir}/")
+
+          relative = binary.sub("#{tmpdir}/", "")
+          dest = File.join(spec.extension_dir, relative)
+          FileUtils.mkdir_p(File.dirname(dest))
+          FileUtils.cp(binary, dest)
+          extracted_count += 1
+        end
+      end
+
+      Logger.info "Installed precompiled #{File.basename(gem_path)} " \
+                  "(#{extracted_count} binary files)"
+    rescue StandardError => e
+      Logger.warn "Extraction failed for #{File.basename(gem_path)}: #{e.message}"
+      raise
+    end
+  end
+end

data/lib/prebake/hooks.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "async_publisher"
+require_relative "logger"
+
+module Prebake
+  module Hooks
+    def self.register!
+      return unless defined?(Bundler::Plugin::API)
+
+      Bundler::Plugin::API.hook("after-install") do |spec_install|
+        next unless Prebake.push_enabled?
+        next unless spec_install.state == :installed
+
+        gem_spec = spec_install.spec
+        next unless gem_spec.extensions.any?
+        next unless gem_spec.platform.to_s == "ruby"
+        next unless File.exist?(gem_spec.gem_build_complete_path)
+
+        AsyncPublisher.enqueue(gem_spec, Prebake.backend)
+      end
+
+      Bundler::Plugin::API.hook("after-install-all") do |_deps|
+        next unless Prebake.push_enabled?
+
+        AsyncPublisher.wait_for_completion
+      end
+
+      Logger.debug "Hooks registered"
+    end
+  end
+end

data/lib/prebake/logger.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Prebake
+  module Logger
+    LEVELS = { debug: 0, info: 1, warn: 2 }.freeze
+
+    def self.level
+      LEVELS.fetch(ENV.fetch("PREBAKE_LOG_LEVEL", "warn").to_sym, 1)
+    end
+
+    def self.debug(msg)
+      return unless level <= 0
+
+      output "  [prebake] #{msg}"
+    end
+
+    def self.info(msg)
+      return unless level <= 1
+
+      output "  [prebake] #{msg}"
+    end
+
+    def self.warn(msg)
+      return unless level <= 2
+
+      output "  [prebake] WARN: #{msg}"
+    end
+
+    def self.output(msg)
+      if defined?(Bundler) && Bundler.respond_to?(:ui)
+        Bundler.ui.info msg
+      else
+        Kernel.warn msg
+      end
+    end
+  end
+end

data/lib/prebake/platform.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Prebake
+  module Platform
+    NORMALIZATIONS = [
+      [/\Aarm64-darwin(-\d+)?\z/, "arm64-darwin"],
+      [/\Ax86_64-darwin(-\d+)?\z/, "x86_64-darwin"],
+      [/\Ax86_64-linux-musl\z/, "x86_64-linux-musl"],
+      [/\Aaarch64-linux-musl\z/, "aarch64-linux-musl"],
+      [/\Ax86_64-linux(-gnu)?\z/, "x86_64-linux"],
+      [/\Aaarch64-linux(-gnu)?\z/, "aarch64-linux"]
+    ].freeze
+
+    def self.normalize(platform_string)
+      NORMALIZATIONS.each do |pattern, normalized|
+        return normalized if platform_string.match?(pattern)
+      end
+
+      platform_string
+    end
+
+    def self.generalized
+      platform = Gem::Platform.local
+      base = normalize(platform.to_s)
+
+      # On Linux, detect musl vs glibc - they produce incompatible binaries.
+      # Gem::Platform.local may report "gnu" even on musl systems, so we
+      # detect explicitly.
+      if platform.os == "linux" && !base.include?("musl") && musl?
+        base.sub(/\z/, "-musl")
+      else
+        base
+      end
+    end
+
+    def self.musl?
+      return false unless RUBY_PLATFORM.include?("linux")
+
+      File.exist?("/lib/ld-musl-x86_64.so.1") ||
+        File.exist?("/lib/ld-musl-aarch64.so.1") ||
+        begin
+          `ldd --version 2>&1`.include?("musl")
+        rescue StandardError
+          false
+        end
+    end
+  end
+end

data/lib/prebake/platform_gem_builder.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "rubygems/package"
+require "fileutils"
+require "digest"
+require "tempfile"
+require "securerandom"
+require_relative "platform"
+require_relative "logger"
+
+module Prebake
+  class PlatformGemBuilder
+    attr_reader :checksum
+
+    def initialize(spec)
+      @spec = spec
+      @checksum = nil
+    end
+
+    def build
+      # Build in a temp directory; Dir.chdir is scoped to it to
+      # isolate from Bundler's working directory.
+      Dir.mktmpdir("prebake-build") do |build_dir|
+        FileUtils.cp_r(File.join(@spec.gem_dir, "."), build_dir)
+
+        platform_spec = build_platform_spec(build_dir)
+
+        gem_file = nil
+        Dir.chdir(build_dir) do
+          gem_file = Gem::Package.build(platform_spec)
+        end
+
+        built_path = File.join(build_dir, gem_file)
+        final = File.join(Dir.tmpdir, "prebake-built-#{SecureRandom.hex(16)}.gem")
+        FileUtils.cp(built_path, final)
+
+        @checksum = Digest::SHA256.file(final).hexdigest
+        Logger.debug "Built #{gem_file} (SHA256: #{@checksum})"
+
+        final
+      end
+    end
+
+    private
+
+    def build_platform_spec(build_dir)
+      platform_spec = @spec.dup
+      platform_spec.platform = Gem::Platform.new(Platform.generalized)
+      platform_spec.extensions = []
+
+      prefix = "#{build_dir}/"
+      compiled = Dir.glob(File.join(build_dir, "**/*.{so,bundle,dll}"))
+                    .map { |f| f.delete_prefix(prefix) }
+      platform_spec.files = platform_spec.files | compiled
+
+      platform_spec
+    end
+  end
+end

data/lib/prebake.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "prebake/logger"
+
+module Prebake
+  class Error < StandardError; end
+
+  # major.minor only - ABI is stable across patch versions
+  RUBY_ABI_VERSION = "#{RbConfig::CONFIG['MAJOR']}.#{RbConfig::CONFIG['MINOR']}".freeze
+
+  @backend_mutex = Mutex.new
+
+  def self.enabled?
+    ENV.fetch("PREBAKE_ENABLED", "true") != "false"
+  end
+
+  def self.push_enabled?
+    enabled? && ENV.fetch("PREBAKE_PUSH_ENABLED", "false") == "true"
+  end
+
+  def self.backend
+    return @backend if defined?(@backend_loaded)
+
+    @backend_mutex.synchronize do
+      return @backend if defined?(@backend_loaded)
+
+      @backend_loaded = true
+      @backend = load_backend
+    end
+  rescue Error => e
+    Logger.warn "Backend initialization failed: #{e.message}. Plugin disabled for this session."
+    @backend = nil
+  end
+
+  def self.backend=(backend)
+    @backend_loaded = true
+    @backend = backend
+  end
+
+  def self.reset!
+    remove_instance_variable(:@backend_loaded) if defined?(@backend_loaded)
+    remove_instance_variable(:@backend) if defined?(@backend)
+  end
+
+  def self.setup!
+    return unless enabled?
+
+    require_relative "prebake/ext_builder_patch"
+    Gem::Ext::Builder.prepend(ExtBuilderPatch)
+
+    require_relative "prebake/hooks"
+    Hooks.register!
+
+    Logger.info "Plugin active (backend: #{backend_type})"
+  rescue StandardError => e
+    Logger.warn "Failed to initialize: #{e.message}"
+  end
+
+  def self.backend_type
+    ENV.fetch("PREBAKE_BACKEND", "http")
+  end
+
+  class << self
+    private
+
+    def load_backend
+      case backend_type
+      when "gemstash"
+        require_relative "prebake/backends/gemstash"
+        url = ENV.fetch("PREBAKE_GEMSTASH_URL") { raise Error, "PREBAKE_GEMSTASH_URL is required" }
+        key = ENV.fetch("PREBAKE_GEMSTASH_KEY", nil)
+        Backends::Gemstash.new(url:, key:)
+      when "s3"
+        require_relative "prebake/backends/s3"
+        bucket = ENV.fetch("PREBAKE_S3_BUCKET") { raise Error, "PREBAKE_S3_BUCKET is required" }
+        Backends::S3.new(
+          bucket:,
+          region: ENV.fetch("PREBAKE_S3_REGION", "us-east-1"),
+          prefix: ENV.fetch("PREBAKE_S3_PREFIX", "prebake")
+        )
+      when "http"
+        require_relative "prebake/backends/http"
+        url = ENV.fetch("PREBAKE_HTTP_URL", "https://gems.prebake.in")
+        Backends::Http.new(url:, token: ENV.fetch("PREBAKE_HTTP_TOKEN", nil))
+      else
+        raise Error, "Unknown backend: #{backend_type}. Use gemstash, s3, or http."
+      end
+    end
+  end
+end

data/plugins.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "lib/prebake"
+
+Prebake.setup! if Prebake.enabled?

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: prebake
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Thejus Paul
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-22 00:00:00.000000000 Z
+dependencies: []
+description: Prebake speeds up bundle install by skipping native gem compilation.
+  It fetches precompiled binaries for gems like puma, nokogiri, pg, grpc, and bootsnap
+  from a shared cache instead of compiling C extensions from source. Drop-in Bundler
+  plugin - one line in your Gemfile, no other changes needed. Works out of the box
+  with the hosted cache at gems.prebake.in, or self-host with S3-compatible storage
+  (AWS S3, Cloudflare R2, Backblaze B2, MinIO) or Gemstash. Works with Ruby 3.2+ and
+  Ruby 4.0 on any platform.
+email:
+- thejuspaul@pm.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/prebake.rb
+- lib/prebake/async_publisher.rb
+- lib/prebake/backends/base.rb
+- lib/prebake/backends/gemstash.rb
+- lib/prebake/backends/http.rb
+- lib/prebake/backends/http_client.rb
+- lib/prebake/backends/s3.rb
+- lib/prebake/cache_key.rb
+- lib/prebake/ext_builder_patch.rb
+- lib/prebake/extractor.rb
+- lib/prebake/hooks.rb
+- lib/prebake/logger.rb
+- lib/prebake/platform.rb
+- lib/prebake/platform_gem_builder.rb
+- plugins.rb
+homepage: https://github.com/gembakery/prebake
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gembakery/prebake
+  source_code_uri: https://github.com/gembakery/prebake
+  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: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Stop compiling. Start installing. Prebake your native gems.
+test_files: []