rubox 0.1.0

data/lib/rubox/builder.rb

@@ -0,0 +1,130 @@
+require "open3"
+require "net/http"
+require "uri"
+require "fileutils"
+
+module Rubox
+  class Builder
+    # Pre-built Ruby binaries are hosted at this base URL.
+    # Falls back to building from source if download fails.
+    DOWNLOAD_BASE = "https://github.com/khasinski/rubox/releases/download"
+
+    attr_reader :ruby_version, :target, :output_dir
+
+    def initialize(ruby_version:, target:, output_dir: nil)
+      @ruby_version = ruby_version
+      @target = target
+      @output_dir = output_dir || "build/ruby-#{ruby_version}-#{target}"
+    end
+
+    def built?
+      File.exist?(File.join(output_dir, "bin", "ruby"))
+    end
+
+    def build!
+      return if built?
+
+      if try_download
+        puts "==> Using pre-built Ruby #{ruby_version} for #{target}"
+        return
+      end
+
+      puts "==> No pre-built binary available, building from source..."
+      build_from_source!
+    end
+
+    private
+
+    def try_download
+      url = "#{DOWNLOAD_BASE}/ruby-#{ruby_version}/ruby-#{ruby_version}-#{target}.tar.gz"
+      tarball = "#{output_dir}.tar.gz"
+
+      puts "==> Checking for pre-built Ruby #{ruby_version} for #{target}..."
+
+      begin
+        uri = URI(url)
+        # Follow redirects (GitHub releases redirect to S3)
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: true,
+                                   open_timeout: 5, read_timeout: 30) do |http|
+          request = Net::HTTP::Head.new(uri)
+          http.request(request)
+        end
+
+        unless response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+          puts "    Not found (#{response.code})"
+          return false
+        end
+
+        puts "    Downloading..."
+        FileUtils.mkdir_p(File.dirname(tarball))
+
+        # Stream download
+        download_file(url, tarball)
+
+        puts "    Extracting..."
+        FileUtils.mkdir_p(output_dir)
+        system("tar", "xzf", tarball, "-C", output_dir, exception: true)
+        FileUtils.rm_f(tarball)
+
+        if built?
+          puts "    Ruby #{ruby_version} ready at #{output_dir}"
+          return true
+        else
+          puts "    Download extracted but Ruby binary not found, falling back to source build"
+          FileUtils.rm_rf(output_dir)
+          return false
+        end
+      rescue StandardError => e
+        puts "    Download failed (#{e.message}), will build from source"
+        FileUtils.rm_f(tarball)
+        return false
+      end
+    end
+
+    def download_file(url, dest)
+      uri = URI(url)
+      max_redirects = 5
+
+      max_redirects.times do
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                        read_timeout: 120) do |http|
+          request = Net::HTTP::Get.new(uri)
+          http.request(request) do |response|
+            case response
+            when Net::HTTPRedirection
+              uri = URI(response["location"])
+              next
+            when Net::HTTPSuccess
+              File.open(dest, "wb") do |f|
+                response.read_body { |chunk| f.write(chunk) }
+              end
+              return
+            else
+              raise "HTTP #{response.code}"
+            end
+          end
+        end
+      end
+
+      raise "Too many redirects"
+    end
+
+    def build_from_source!
+      Rubox.validate_data_dir!
+      script = File.join(Rubox.data_dir, "scripts", "build-ruby.sh")
+
+      env = {
+        "RUBOX_DATA_DIR" => Rubox.data_dir,
+      }
+
+      cmd = [
+        script,
+        "--ruby-version", ruby_version,
+        "--target", target,
+        "--output", output_dir,
+      ]
+
+      system(env, *cmd, exception: true)
+    end
+  end
+end

data/lib/rubox/cli.rb

@@ -0,0 +1,214 @@
+require "optparse"
+require "rubox"
+
+module Rubox
+  class CLI
+    def self.run(argv)
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+      @options = {
+        prune: "default",
+        yes: false,
+      }
+    end
+
+    def run
+      command = @argv.shift
+
+      case command
+      when "pack"
+        parse_pack_options!
+        cmd_pack
+      when "build-ruby"
+        parse_build_options!
+        cmd_build_ruby
+      when "clean"
+        cmd_clean
+      when "-h", "--help", "help", nil
+        print_usage
+      when "-v", "--version"
+        puts "rubox #{VERSION}"
+      else
+        $stderr.puts "Unknown command: #{command}"
+        $stderr.puts "Run: rubox --help"
+        exit 1
+      end
+    end
+
+    private
+
+    def parse_pack_options!
+      OptionParser.new do |opts|
+        opts.banner = "Usage: rubox pack [options]"
+        opts.on("--gem NAME", "Package a rubygems gem") { |v| @options[:gem] = v }
+        opts.on("--gemfile PATH", "Package a Gemfile-based app") { |v| @options[:gemfile] = v }
+        opts.on("--entry BIN", "Entry point binary name") { |v| @options[:entry] = v }
+        opts.on("--target TARGET", "Target platform") { |v| @options[:target] = v }
+        opts.on("--output PATH", "Output binary path") { |v| @options[:output] = v }
+        opts.on("--prune LEVEL", "Prune level: none, default") { |v| @options[:prune] = v }
+        opts.on("--keep-gems LIST", "Comma-separated gems to keep") { |v| @options[:keep_gems] = v }
+        opts.on("-y", "--yes", "Skip confirmation prompts") { @options[:yes] = true }
+      end.parse!(@argv)
+    end
+
+    def parse_build_options!
+      OptionParser.new do |opts|
+        opts.banner = "Usage: rubox build-ruby [options]"
+        opts.on("--target TARGET", "Target platform") { |v| @options[:target] = v }
+        opts.on("--ruby-version VER", "Ruby version") { |v| @options[:ruby_version] = v }
+        opts.on("-y", "--yes", "Skip confirmation prompts") { @options[:yes] = true }
+      end.parse!(@argv)
+    end
+
+    def cmd_pack
+      detector = Detector.new
+
+      if detector.has_config?
+        puts "Using config: #{Detector::CONFIG_FILE}"
+      end
+
+      # Merge: CLI flags > .rubox.yml > auto-detection
+      target = @options[:target] || detector.target || Platform.host_target
+      gem_name = @options[:gem] || detector.gem_name
+      gemfile = @options[:gemfile]
+
+      if gem_name.nil? && gemfile.nil?
+        gemfile = detector.gemfile_path
+        if gemfile
+          puts "Detected Gemfile: #{gemfile}"
+        else
+          $stderr.puts "ERROR: No --gem or --gemfile specified and no Gemfile found in #{Dir.pwd}"
+          exit 1
+        end
+      end
+
+      ruby_version = @options[:ruby_version] || detector.ruby_version
+      entry = @options[:entry] || (gem_name if gem_name) || detector.entry_name
+
+      # Output path
+      output = @options[:output] || begin
+        name = entry || gem_name || File.basename(Dir.pwd)
+        suffix = (target != Platform.host_target) ? "-#{target}" : ""
+        "build/#{name}#{suffix}"
+      end
+
+      ruby_dir = "build/ruby-#{ruby_version}-#{target}"
+
+      # Build Ruby if needed
+      builder = Builder.new(ruby_version: ruby_version, target: target, output_dir: ruby_dir)
+
+      unless builder.built?
+        puts ""
+        puts "rubox needs to fetch and compile a static Ruby #{ruby_version} for #{target}."
+        puts "This is a one-time operation (cached for future builds)."
+        puts ""
+
+        unless @options[:yes]
+          print "Continue? [y/N] "
+          answer = $stdin.gets&.strip&.downcase
+          unless answer == "y" || answer == "yes"
+            puts "Aborted."
+            exit 0
+          end
+        end
+
+        builder.build!
+      end
+
+      # Install gem if needed
+      packager = Packager.new(
+        ruby_dir: ruby_dir,
+        output: output,
+        target: target,
+        gem_name: gem_name,
+        gemfile: gemfile,
+        entry: entry,
+        prune: @options[:prune] || detector.prune || "default",
+        keep_gems: @options[:keep_gems] || detector.keep_gems,
+      )
+
+      if gem_name
+        gem_found = Dir.glob(File.join(ruby_dir, "lib/ruby/gems/*/gems/#{gem_name}-*")).any?
+        unless gem_found
+          packager.install_gem!(gem_name)
+        end
+      end
+
+      packager.package!
+
+      puts ""
+      puts "Binary ready: #{output}"
+    end
+
+    def cmd_build_ruby
+      detector = Detector.new
+      ruby_version = @options[:ruby_version] || detector.ruby_version
+      target = @options[:target]
+
+      builder = Builder.new(ruby_version: ruby_version, target: target)
+
+      if builder.built?
+        puts "Ruby #{ruby_version} for #{target} already built at #{builder.output_dir}"
+        return
+      end
+
+      puts ""
+      puts "rubox needs to fetch and compile a static Ruby #{ruby_version} for #{target}."
+      puts "This is a one-time operation."
+      puts ""
+
+      unless @options[:yes]
+        print "Continue? [y/N] "
+        answer = $stdin.gets&.strip&.downcase
+        unless answer == "y" || answer == "yes"
+          puts "Aborted."
+          exit 0
+        end
+      end
+
+      builder.build!
+    end
+
+    def cmd_clean
+      puts "Cleaning build artifacts..."
+      FileUtils.rm_rf("build")
+      puts "Done."
+    end
+
+    def print_usage
+      puts <<~USAGE
+        rubox v#{VERSION} - Package Ruby apps into single portable binaries.
+
+        Usage:
+          rubox pack [options]       Package a gem or app into a single binary
+          rubox build-ruby [options]  Build the static Ruby interpreter
+          rubox clean                 Remove build artifacts
+          rubox --version             Show version
+
+        Pack options:
+          --gem NAME        Package a rubygems gem
+          --gemfile PATH    Package a Gemfile-based app (auto-detected if present)
+          --entry BIN       Entry point binary name (defaults to gem name)
+          --target TARGET   Target platform (default: #{Platform.host_target})
+          --output PATH     Output binary path
+          --prune LEVEL     Prune level: none, default (default: default)
+          --keep-gems LIST  Comma-separated gems to keep despite prune list
+          -y, --yes         Skip confirmation prompts
+
+        Targets:
+          aarch64-darwin    macOS Apple Silicon
+          x86_64-darwin     macOS Intel
+          aarch64-linux     Linux ARM64
+          x86_64-linux      Linux x86_64
+
+        Examples:
+          rubox pack --gem herb
+          rubox pack                      # auto-detects Gemfile
+          rubox pack -y --target aarch64-linux
+      USAGE
+    end
+  end
+end

data/lib/rubox/detector.rb

@@ -0,0 +1,105 @@
+require "yaml"
+
+module Rubox
+  class Detector
+    CONFIG_FILE = ".rubox.yml"
+
+    attr_reader :dir
+
+    def initialize(dir = Dir.pwd)
+      @dir = dir
+      @config = load_config
+    end
+
+    def config
+      @config
+    end
+
+    def ruby_version
+      @config["ruby_version"] || from_ruby_version_file || from_gemfile || current_ruby_version
+    end
+
+    def gemfile_path
+      if @config["gemfile"]
+        path = File.expand_path(@config["gemfile"], dir)
+        return path if File.exist?(path)
+      end
+
+      %w[Gemfile gems.rb].each do |name|
+        path = File.join(dir, name)
+        return path if File.exist?(path)
+      end
+      nil
+    end
+
+    def entry_name
+      return @config["entry"] if @config["entry"]
+
+      gemspec = Dir.glob(File.join(dir, "*.gemspec")).first
+      if gemspec
+        content = File.read(gemspec)
+        if content =~ /spec\.executables\s*=.*?["']([^"']+)["']/
+          return $1
+        end
+      end
+
+      File.basename(dir)
+    end
+
+    def target
+      @config["target"]
+    end
+
+    def prune
+      @config["prune"]
+    end
+
+    def keep_gems
+      gems = @config["keep_gems"]
+      gems.is_a?(Array) ? gems.join(",") : gems
+    end
+
+    def gem_name
+      @config["gem"]
+    end
+
+    def has_config?
+      File.exist?(File.join(dir, CONFIG_FILE))
+    end
+
+    private
+
+    def load_config
+      path = File.join(dir, CONFIG_FILE)
+      return {} unless File.exist?(path)
+
+      config = YAML.safe_load_file(path, permitted_classes: [Symbol]) || {}
+      config.transform_keys(&:to_s)
+    rescue => e
+      $stderr.puts "rubox: warning: failed to parse #{CONFIG_FILE}: #{e.message}"
+      {}
+    end
+
+    def from_ruby_version_file
+      path = File.join(dir, ".ruby-version")
+      return nil unless File.exist?(path)
+
+      version = File.read(path).strip.sub(/^ruby-/, "")
+      version.match?(/^\d+\.\d+\.\d+$/) ? version : nil
+    end
+
+    def from_gemfile
+      path = gemfile_path
+      return nil unless path
+
+      content = File.read(path)
+      if content =~ /^\s*ruby\s+["'](\d+\.\d+\.\d+)["']/
+        $1
+      end
+    end
+
+    def current_ruby_version
+      RUBY_VERSION
+    end
+  end
+end

data/lib/rubox/packager.rb

@@ -0,0 +1,118 @@
+module Rubox
+  class Packager
+    def initialize(ruby_dir:, output:, target:, gem_name: nil, gemfile: nil,
+                   entry: nil, prune: "default", keep_gems: nil)
+      @ruby_dir = ruby_dir
+      @output = output
+      @target = target
+      @gem_name = gem_name
+      @gemfile = gemfile
+      @entry = entry || gem_name
+      @prune = prune
+      @keep_gems = keep_gems
+    end
+
+    def package!
+      Rubox.validate_data_dir!
+      script = File.join(Rubox.data_dir, "scripts", "package.sh")
+      stub = stub_path
+      ensure_write_footer!
+
+      args = [
+        script,
+        "--ruby-dir", @ruby_dir,
+        "--stub", stub,
+        "--output", @output,
+        "--prune", @prune,
+      ]
+
+      if @gem_name
+        args += ["--gem", @gem_name]
+        args += ["--entry", @entry] if @entry
+      elsif @gemfile
+        args += ["--gemfile", @gemfile]
+        args += ["--entry", @entry] if @entry
+      end
+
+      args += ["--keep-gems", @keep_gems] if @keep_gems
+
+      env = {
+        "RUBOX_DATA_DIR" => Rubox.data_dir,
+      }
+
+      system(env, *args, exception: true)
+    end
+
+    def install_gem!(gem_name)
+      ruby_bin = File.join(@ruby_dir, "bin", "ruby")
+
+      if File.exist?(ruby_bin) && system(ruby_bin, "--version", out: File::NULL, err: File::NULL)
+        # Native platform -- run gem install directly
+        gem_cmd = File.join(@ruby_dir, "bin", "gem")
+        system(gem_cmd, "install", gem_name, "--no-document", exception: true)
+      else
+        # Cross-platform -- use Docker
+        puts "Installing #{gem_name} via Docker (cross-platform)..."
+        docker_platform = @target.start_with?("x86_64") ? "linux/amd64" : "linux/arm64"
+        system(
+          "docker", "run", "--rm", "--platform", docker_platform,
+          "-v", "#{File.expand_path(@ruby_dir)}:/opt/ruby",
+          "alpine:3.21",
+          "sh", "-c",
+          "apk add --no-cache build-base libgcc >/dev/null 2>&1 && /opt/ruby/bin/gem install #{gem_name} --no-document",
+          exception: true
+        )
+      end
+    end
+
+    private
+
+    # Find a pre-built stub for the target, or compile one from source.
+    def stub_path
+      prebuilt = File.join(Rubox.data_dir, "stubs", "stub-#{@target}")
+      return prebuilt if File.exist?(prebuilt)
+
+      # No pre-built stub -- compile from source
+      stub = File.join("build", "stub-#{@target}")
+      unless File.exist?(stub)
+        Dir.mkdir("build") unless Dir.exist?("build")
+        src = File.join(Rubox.data_dir, "ext", "stub.c")
+
+        if Platform.cross_build?(@target)
+          puts "Cross-compiling stub for #{@target} via Docker..."
+          docker_platform = @target.start_with?("x86_64") ? "linux/amd64" : "linux/arm64"
+          system(
+            "docker", "run", "--rm", "--platform", docker_platform,
+            "-v", "#{Dir.pwd}:/src", "-w", "/src",
+            "alpine:3.21",
+            "sh", "-c",
+            "apk add --no-cache gcc musl-dev >/dev/null 2>&1 && " \
+            "cc -O2 -Wall -Wextra -static -o #{stub} #{src}",
+            exception: true
+          )
+        else
+          system("cc", "-O2", "-Wall", "-Wextra", "-o", stub, src, exception: true)
+        end
+      end
+      stub
+    end
+
+    def ensure_write_footer!
+      prebuilt = File.join(Rubox.data_dir, "stubs", "write-footer-#{@target}")
+      if File.exist?(prebuilt)
+        # Symlink pre-built into build/ so package.sh can find it
+        Dir.mkdir("build") unless Dir.exist?("build")
+        wf = File.join("build", "write-footer")
+        FileUtils.cp(prebuilt, wf) unless File.exist?(wf)
+        return
+      end
+
+      wf = File.join("build", "write-footer")
+      return if File.exist?(wf)
+
+      Dir.mkdir("build") unless Dir.exist?("build")
+      src = File.join(Rubox.data_dir, "ext", "write-footer.c")
+      system("cc", "-O2", "-Wall", "-Wextra", "-o", wf, src, exception: true)
+    end
+  end
+end

data/lib/rubox/platform.rb

@@ -0,0 +1,40 @@
+module Rubox
+  module Platform
+    def self.host_arch
+      arch = RbConfig::CONFIG["host_cpu"] || `uname -m`.strip
+      case arch
+      when /arm64|aarch64/ then "aarch64"
+      when /x86_64|amd64/  then "x86_64"
+      else arch
+      end
+    end
+
+    def self.host_os
+      case RbConfig::CONFIG["host_os"]
+      when /darwin/ then "darwin"
+      when /linux/  then "linux"
+      else `uname -s`.strip.downcase
+      end
+    end
+
+    def self.host_target
+      "#{host_arch}-#{host_os}"
+    end
+
+    def self.valid_targets
+      %w[aarch64-darwin x86_64-darwin aarch64-linux x86_64-linux]
+    end
+
+    def self.valid_target?(target)
+      valid_targets.include?(target)
+    end
+
+    def self.cross_build?(target)
+      target != host_target
+    end
+
+    def self.linux_target?(target)
+      target.end_with?("-linux")
+    end
+  end
+end

data/lib/rubox/version.rb

@@ -0,0 +1,3 @@
+module Rubox
+  VERSION = "0.1.0"
+end

data/lib/rubox.rb

@@ -0,0 +1,31 @@
+require "fileutils"
+require "rubox/version"
+require "rubox/platform"
+require "rubox/detector"
+require "rubox/builder"
+require "rubox/packager"
+
+module Rubox
+  def self.data_dir
+    @data_dir ||= File.expand_path("../data", __dir__)
+  end
+
+  REQUIRED_DATA_FILES = %w[
+    scripts/build-ruby.sh
+    scripts/package.sh
+    scripts/_common.sh
+    ext/stub.c
+    ext/write-footer.c
+    Dockerfile.ruby-build
+    prune-list.conf
+  ].freeze
+
+  def self.validate_data_dir!
+    missing = REQUIRED_DATA_FILES.select { |f| !File.exist?(File.join(data_dir, f)) }
+    return if missing.empty?
+
+    abort "rubox: data directory incomplete (#{data_dir}).\n" \
+          "Missing: #{missing.join(', ')}\n" \
+          "Reinstall the gem: gem install rubox"
+  end
+end