ruby_everywhere 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39645f3a9d06b112aacb1d2f6863914e355b027f73601de21a04fb2d45b0f1a9
-  data.tar.gz: 87e978358814f098d3f1c596edc5d75b1f843608bde316fc0cebf159a57ffb5f
+  metadata.gz: 75b09aedaa84953cf39a5b6bc7e793f660998f297d5c7cc74ed453fef68172f3
+  data.tar.gz: f1970350eaaedaf2fed2fd6123a25c152f196019256d5c2ff848a0a262f589c7
 SHA512:
-  metadata.gz: bc57bb378e7b44fc08e5a2e5a5929a240ef6be7ac7bc506302a597aaa829c116fb8df391313dcb879824a420b0befeb6b72ee66f8993b1ab393fc274fc0ffcb4
-  data.tar.gz: 1aae4125b5d23220f900c0650b88102f09b274213aea8c201e0fb435ebc8b38bb7bd3b4a546b58a805f92ee3533e6f7305ab53b5cfdd51a0fe80946485d72558
+  metadata.gz: 3f611fb7632f07a4931b659166ad6c1e0e773b7fa979b38c66f109cb0c22ace4c9710bd977e112d40bceee6efdd358fe5283262d7218f60e36f267e4456e6f5f
+  data.tar.gz: '08def4faa79e14355864dd66369a8cfb06884b062186234d96478c9cbe3edd9957f14e46319bd2276f5927728ccea0ce442ae6d216b2bc851cd059de815f84a3'

data/exe/every

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "everywhere/cli"
+
+Dry::CLI.new(Everywhere::CLI).call

data/exe/rbe

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "everywhere/cli"
+
+Dry::CLI.new(Everywhere::CLI).call

data/lib/everywhere/boot.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "securerandom"
+
+module Everywhere
+  # Runtime boot for the packaged desktop build. Called from the app's
+  # generated native_boot.rb stub (after the bundle is set up):
+  #
+  #   Everywhere.boot!(root: __dir__)
+  #
+  # This core is framework-neutral. Its responsibilities:
+  #   1. Resolve a writable per-user app-data directory (packaged FS is read-only)
+  #   2. Generate a per-install SECRET_KEY_BASE on first boot
+  #   3. Copy static assets to a writable dir (the memfs truncates large files)
+  #   4. Watch the shell process and shut down if it dies
+  #
+  # Everything framework-specific — loading the app, preparing the database, and
+  # starting the server — is delegated to the detected Framework adapter, so
+  # Rails, Sinatra, and Hanami each own their own boot path.
+  #
+  # The desktop shell passes NATIVE_PORT and NATIVE_APPDATA; standalone runs
+  # (debugging) get a free port and a config-derived app-data dir.
+  class Boot
+    def self.call(root:)
+      new(root).call
+    end
+
+    attr_reader :root, :config
+
+    def initialize(root)
+      @root = File.expand_path(root)
+      @config = Config.load(@root)
+    end
+
+    def call
+      ENV["NATIVE_PACKAGED"] ||= "1"
+
+      framework = Framework.detect(root)
+      framework.prepare_runtime_env
+
+      prepare_app_data
+      ensure_secret_key_base
+      extract_public_dir
+
+      Dir.chdir(root)
+      watch_shell
+
+      port = ENV["NATIVE_PORT"] || free_port
+      puts "[everywhere] framework: #{framework.name}"
+      puts "[everywhere] app data:  #{app_data}"
+      puts "[everywhere] app running at http://127.0.0.1:#{port}"
+
+      framework.boot!(port: port)
+    end
+
+    private
+
+    def app_data
+      @app_data ||= ENV["NATIVE_APPDATA"] || default_app_data
+    end
+
+    # Same layout the desktop shell uses: platform data dir + bundle_id.
+    def default_app_data
+      case RUBY_PLATFORM
+      when /darwin/
+        File.join(Dir.home, "Library", "Application Support", config.bundle_id)
+      when /mingw|mswin/
+        File.join(ENV.fetch("APPDATA"), config.bundle_id)
+      else
+        File.join(ENV.fetch("XDG_DATA_HOME", File.join(Dir.home, ".local", "share")),
+                  config.bundle_id)
+      end
+    end
+
+    def prepare_app_data
+      storage = File.join(app_data, "storage")
+      FileUtils.mkdir_p(storage)
+      ENV["NATIVE_STORAGE_DIR"] = storage
+    end
+
+    # Files larger than ~64KB truncate when streamed from the tebako memfs
+    # (Rack::Files sends an empty body), so static assets are served from a
+    # real-disk copy in app-data instead. The everywhere initializer points
+    # Rails.public_path here via NATIVE_PUBLIC_DIR.
+    def extract_public_dir
+      return unless ENV["NATIVE_PACKAGED"] == "1"
+
+      source = File.join(root, "public")
+      return unless File.directory?(source)
+
+      target = File.join(app_data, "public")
+      FileUtils.rm_rf(target)
+      FileUtils.cp_r(source, target)
+      ENV["NATIVE_PUBLIC_DIR"] = target
+    end
+
+    def ensure_secret_key_base
+      secret_file = File.join(app_data, "secret_key_base")
+      unless File.exist?(secret_file)
+        File.write(secret_file, SecureRandom.hex(64))
+        File.chmod(0o600, secret_file)
+      end
+      ENV["SECRET_KEY_BASE"] ||= File.read(secret_file).strip
+    end
+
+    # If the desktop shell dies without cleanup (crash, force-quit, SIGKILL),
+    # shut the server down rather than lingering as an orphan. TERM to self
+    # gives Puma a graceful stop, which also stops Solid Queue's processes.
+    def watch_shell
+      shell_pid = ENV["NATIVE_SHELL_PID"].to_i
+      return unless shell_pid.positive?
+
+      Thread.new do
+        loop do
+          sleep 2
+          begin
+            Process.kill(0, shell_pid)
+          rescue Errno::ESRCH
+            Process.kill("TERM", Process.pid)
+            sleep 10
+            exit!(1)
+          end
+        end
+      end
+    end
+
+    def free_port
+      require "socket"
+      server = TCPServer.new("127.0.0.1", 0)
+      server.addr[1].to_s.tap { server.close }
+    end
+  end
+
+  def self.boot!(root:)
+    Boot.call(root: root)
+  end
+end

data/lib/everywhere/cli.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require_relative "../everywhere"
+require_relative "framework"
+require_relative "commands/build"
+require_relative "commands/dev"
+require_relative "commands/doctor"
+require_relative "commands/install"
+require_relative "commands/release"
+require_relative "commands/platform/login"
+require_relative "commands/platform/logout"
+require_relative "commands/platform/auth_status"
+require_relative "commands/platform/build"
+require_relative "commands/platform/runner"
+
+module Everywhere
+  module Commands
+    class Version < Dry::CLI::Command
+      desc "Print version"
+
+      def call(**)
+        puts "ruby_everywhere #{Everywhere::VERSION}"
+      end
+    end
+  end
+
+  module CLI
+    extend Dry::CLI::Registry
+
+    register "version", Commands::Version, aliases: ["-v", "--version"]
+    register "doctor",  Commands::Doctor
+    register "install", Commands::Install
+    register "dev",     Commands::Dev
+    register "build",   Commands::Build
+    register "release", Commands::Release
+
+    register "platform login",       Commands::PlatformLogin
+    register "platform logout",      Commands::PlatformLogout
+    register "platform auth status", Commands::PlatformAuthStatus
+    register "platform build",       Commands::PlatformBuild
+    register "platform runner",      Commands::PlatformRunner
+  end
+end

data/lib/everywhere/commands/build.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "fileutils"
+require "tmpdir"
+require "shellwords"
+require_relative "../shellout"
+require_relative "../png"
+
+module Everywhere
+  module Commands
+    # Press the app into a single-file binary and make it runnable on this Mac.
+    #
+    # Encodes the Xcode 26 / macOS 26 workarounds discovered in the Phase 0 spike:
+    #   1. CXX compiler shim (fmt consteval + folly __compressed_pair fixes)
+    #   2. BUNDLE_FORCE_RUBY_PLATFORM so native gems compile from source
+    #      (tebako's strip corrupts precompiled gems' signatures -> SIGKILL)
+    #   3. Homebrew bison on PATH + LG_VADDR for tebako itself
+    #   4. Post-press ad-hoc re-sign (macOS 26 rejects the pressed signature)
+    class Build < Dry::CLI::Command
+      SHIM = File.expand_path("~/.tebako-shims/clang++")
+
+      desc "Package the app into a double-clickable desktop app (tebako press + shell + .app bundle)"
+
+      option :root,       default: ".",              desc: "App root directory"
+      option :output,     default: nil,              desc: "Output binary path (default: dist/<app>)"
+      option :ruby,       default: "4.0.6",          desc: "Ruby version to package"
+      option :entry,      default: "native_boot.rb", desc: "Entry point script relative to root"
+      option :app_name,   default: nil,              desc: "Bundle name (default: capitalized app dir)"
+      option :shell_dir,  default: nil,              desc: "Path to the shell's src-tauri directory"
+      option :skip_press, type: :boolean, default: false, desc: "Reuse the existing pressed binary, only rebuild the .app"
+
+      def call(root: ".", output: nil, ruby: "4.0.6", entry: "native_boot.rb",
+               app_name: nil, shell_dir: nil, skip_press: false, **)
+        root_path = File.expand_path(root)
+        config = Everywhere::Config.load(root_path)
+        app_name ||= config.name
+
+        # Remote mode: thin shell around an already-deployed app. No Rails app
+        # required locally, nothing to press — just shell + config in a bundle.
+        if config.remote?
+          UI.step("#{UI.bold("remote")} mode → #{UI.cyan(config.remote_url)} #{UI.dim("(no local server packaged)")}")
+          app_dir = bundle_app(nil, app_name, shell_dir, config, dist_dir: File.expand_path("dist", root_path))
+          return
+        end
+
+        framework = Framework.detect(root)
+        output ||= File.join("dist", File.basename(framework.root))
+        output_path = File.expand_path(output)
+        entry_path = File.join(framework.root, entry)
+
+        unless File.exist?(entry_path)
+          UI.die!("#{entry} not found in #{framework.root} — the app needs a packaged-boot entry point")
+        end
+
+        UI.step("#{UI.bold(framework.name)} app at #{framework.root}")
+
+        if skip_press
+          UI.die!("--skip-press given but #{output} doesn't exist") unless File.exist?(output_path)
+          UI.step("reusing pressed binary #{output}")
+        else
+          press!(framework, entry, ruby, output_path)
+        end
+
+        bundle_app(output_path, app_name, shell_dir, config) if RUBY_PLATFORM.include?("darwin")
+
+        UI.success("built #{output} (#{(File.size(output_path) / 1024.0 / 1024.0).round}MB)")
+      end
+
+      private
+
+      def press!(framework, entry, ruby, output_path)
+        UI.step("precompiling assets")
+        Shellout.run!(framework.precompile_env, framework.precompile_command, chdir: framework.root)
+
+        out_dir = File.dirname(output_path)
+        # Tebako packages the whole app root, so stale build products in an
+        # in-root dist/ (previous binaries, .app bundles, logs) would get baked
+        # into the new binary. dist/ is ours — clear it.
+        FileUtils.rm_rf(out_dir) if out_dir.start_with?(framework.root + File::SEPARATOR)
+        FileUtils.mkdir_p(out_dir)
+        # Press into a staging dir OUTSIDE the app root for the same reason
+        # (tebako prints a big warning about exactly this).
+        staging = File.join(Dir.mktmpdir("everywhere-press"), File.basename(output_path))
+        log = "#{output_path}.build.log"
+
+        UI.step("rbe-tebako press (Ruby #{ruby}) #{UI.dim("— grab a coffee on first run")}")
+        UI.step(UI.dim("full build log: #{log}"))
+        Shellout.run_logged!(press_env, ["rbe-tebako", "press",
+             "--root=#{framework.root}", "--entry-point=#{entry}",
+             "--Ruby=#{ruby}", "--output=#{staging}"], log: log)
+
+        # Tebako's final strip step only warns (and still exits 0) if it can't
+        # write the output, so verify the artifact instead of trusting exit codes.
+        UI.die!("tebako reported success but no binary was created") unless File.exist?(staging)
+        FileUtils.mv(staging, output_path)
+
+        UI.step("re-signing for macOS")
+        Shellout.run!({}, "codesign", "--remove-signature", output_path)
+        Shellout.run!({}, "codesign", "-s", "-", output_path)
+
+        # Leaving precompiled assets behind shadows dev-mode assets (new JS
+        # wouldn't load in `every dev` until someone clobbers by hand).
+        UI.step("cleaning up precompiled assets")
+        Shellout.run!(framework.precompile_env, framework.cleanup_command, chdir: framework.root)
+
+        surface_warnings(log)
+      end
+
+      # Assemble dist/<App Name>.app: the release shell binary + the pressed
+      # Rails binary (as "app-server") + Info.plist + icon. An .app bundle is
+      # just a directory layout, so we build it by hand — no tauri-cli needed.
+      def bundle_app(server_binary, app_name, shell_dir, config, dist_dir: nil)
+        shell_dir ||= find_shell_dir
+        dist_dir ||= File.dirname(server_binary)
+
+        icon_source = config.icon
+        if icon_source && !File.exist?(icon_source)
+          UI.warn "app icon #{icon_source} not found — using placeholder"
+          icon_source = nil
+        end
+        UI.step("app icon: #{icon_source ? icon_source.sub("#{config.root}/", "") : "placeholder"}")
+
+        # Tauri bakes icons/icon.png into the shell binary and sets it as the
+        # Dock icon at runtime (stomping the bundle's icns after launch), so the
+        # shell must be COMPILED with the app's icon. Swap it in for the build,
+        # restore the placeholder after; touch build.rs so tauri-build re-embeds.
+        shell_icon = File.join(shell_dir, "icons", "icon.png")
+        placeholder_backup = "#{shell_icon}.placeholder"
+        if icon_source
+          FileUtils.cp(shell_icon, placeholder_backup) unless File.exist?(placeholder_backup)
+          unless Everywhere::PNG.ensure_rgba(icon_source, shell_icon)
+            UI.warn "couldn't convert #{File.basename(icon_source)} to RGBA (unusual PNG flavor) — Dock icon will use the placeholder after launch"
+            FileUtils.cp(placeholder_backup, shell_icon)
+          end
+          FileUtils.touch(File.join(shell_dir, "build.rs"))
+        end
+
+        UI.step("building shell #{UI.dim("(cargo release)")}")
+        begin
+          Shellout.run!({}, "cargo", "build", "--release", chdir: shell_dir)
+        ensure
+          if icon_source && File.exist?(placeholder_backup)
+            FileUtils.mv(placeholder_backup, shell_icon)
+            FileUtils.touch(File.join(shell_dir, "build.rs"))
+          end
+        end
+        shell_bin = Dir[File.join(shell_dir, "target/release/*")]
+                    .find { |f| File.file?(f) && File.executable?(f) && !f.end_with?(".d") }
+        UI.die!("couldn't find release shell binary in #{shell_dir}/target/release") unless shell_bin
+
+        app_dir = File.join(dist_dir, "#{app_name}.app")
+        macos = File.join(app_dir, "Contents", "MacOS")
+        resources = File.join(app_dir, "Contents", "Resources")
+        UI.step("assembling #{File.basename(app_dir)}")
+        FileUtils.rm_rf(app_dir)
+        FileUtils.mkdir_p([macos, resources])
+
+        exe_name = app_name.gsub(/\s+/, "")
+        FileUtils.cp(shell_bin, File.join(macos, exe_name))
+        FileUtils.cp(server_binary, File.join(macos, "app-server")) if server_binary
+
+        File.write(File.join(resources, "everywhere.json"), config.to_shell_json)
+        if (splash = config.splash)
+          if File.exist?(splash)
+            FileUtils.cp(splash, File.join(resources, "splash.html"))
+            UI.step("custom splash: #{splash.sub("#{config.root}/", "")}")
+          else
+            UI.warn "splash #{splash} not found — using the default splash"
+          end
+        end
+        icns = make_icns(icon_source || File.join(shell_dir, "icons", "icon.png"), resources)
+        File.write(File.join(app_dir, "Contents", "Info.plist"),
+                   info_plist(app_name, exe_name, icns, config.bundle_id, config.version))
+
+        UI.step("signing #{File.basename(app_dir)}")
+        Shellout.run!({}, "codesign", "-s", "-", "-f", File.join(macos, "app-server")) if server_binary
+        Shellout.run!({}, "codesign", "-s", "-", "-f", File.join(macos, exe_name))
+        Shellout.run!({}, "codesign", "-s", "-", "-f", app_dir)
+
+        # macOS caches app icons by bundle path; re-register so icon changes
+        # show up without the user hunting down cache-flush incantations.
+        Shellout.run?("/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f #{app_dir.shellescape} 2>/dev/null")
+
+        UI.success("app bundle: #{app_dir.sub("#{Dir.pwd}/", "")} #{UI.dim("(open it!)")}")
+      end
+
+      def find_shell_dir
+        candidates = ["shell/src-tauri", "../shell/src-tauri", "src-tauri"]
+        found = candidates.find { |c| File.exist?(File.join(c, "tauri.conf.json")) }
+        found ? File.expand_path(found) : UI.die!("couldn't find the shell (looked in #{candidates.join(", ")}); pass --shell-dir")
+      end
+
+      # macOS ships everything needed to make an .icns from a png.
+      def make_icns(png, resources_dir)
+        return nil unless File.exist?(png)
+
+        require "shellwords"
+        Dir.mktmpdir do |tmp|
+          iconset = File.join(tmp, "App.iconset")
+          FileUtils.mkdir_p(iconset)
+          [16, 32, 128, 256, 512].each do |size|
+            [[size, "icon_#{size}x#{size}.png"], [size * 2, "icon_#{size}x#{size}@2x.png"]].each do |px, name|
+              Shellout.run?("sips -z #{px} #{px} #{png.shellescape} --out #{File.join(iconset, name).shellescape} >/dev/null 2>&1")
+            end
+          end
+          out = File.join(resources_dir, "AppIcon.icns")
+          return "AppIcon" if Shellout.run?("iconutil -c icns #{iconset.shellescape} -o #{out.shellescape} >/dev/null 2>&1")
+        end
+        nil
+      end
+
+      # CFBundleShortVersionString is the user-facing marketing version; both it
+      # and CFBundleVersion come from `app.version` in everywhere.yml (via
+      # config.version), so the bundle and the release.json receipt agree.
+      def info_plist(app_name, exe_name, icon, identifier, version)
+        icon_keys = icon ? "  <key>CFBundleIconFile</key><string>#{icon}</string>\n" : ""
+        <<~PLIST
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0">
+          <dict>
+            <key>CFBundleName</key><string>#{app_name}</string>
+            <key>CFBundleDisplayName</key><string>#{app_name}</string>
+            <key>CFBundleExecutable</key><string>#{exe_name}</string>
+            <key>CFBundleIdentifier</key><string>#{identifier}</string>
+            <key>CFBundlePackageType</key><string>APPL</string>
+            <key>CFBundleShortVersionString</key><string>#{version}</string>
+            <key>CFBundleVersion</key><string>#{version}</string>
+            <key>LSMinimumSystemVersion</key><string>13.0</string>
+            <key>NSHighResolutionCapable</key><true/>
+          #{icon_keys}</dict>
+          </plist>
+        PLIST
+      end
+
+      private
+
+      # Tebako's output is thousands of lines; re-surface the warnings that
+      # actually matter to the app developer after the build finishes.
+      def surface_warnings(log)
+        return unless File.exist?(log)
+
+        text = File.read(log)
+
+        if text.match?(/could not strip|string table not at the end/)
+          UI.warn "some binaries couldn't be stripped of debug symbols (harmless; " \
+                  "binary is a bit larger than it could be)"
+        end
+        if text.match?(/incbin is incompatible with bitcode/)
+          # Bitcode was removed by Apple in Xcode 14 — irrelevant, don't alarm anyone.
+          nil
+        end
+
+        press_warnings = text.scan(/^.*(?:WARNING|Warning):(?!.*bitcode).*$/).size
+        UI.warn "tebako emitted #{press_warnings} warning(s) — details in the build log" if press_warnings.positive?
+      end
+
+      def press_env
+        env = {
+          "BUNDLE_FORCE_RUBY_PLATFORM" => "true",
+          "LG_VADDR" => "39"
+        }
+        env["CXX"] = SHIM if File.exist?(SHIM)
+        bison = `brew --prefix bison 2>/dev/null`.strip
+        env["PATH"] = "#{bison}/bin:#{ENV.fetch("PATH")}" unless bison.empty?
+        env
+      end
+
+    end
+  end
+end

data/lib/everywhere/commands/dev.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "socket"
+require_relative "../shellout"
+
+module Everywhere
+  module Commands
+    # Run the app's normal dev server and open the desktop shell pointed at it.
+    # No packaging: the shell skips the sidecar when NATIVE_DEV_URL is set,
+    # so the edit-refresh loop is untouched Rails/Hanami.
+    class Dev < Dry::CLI::Command
+      desc "Run the dev server inside the desktop shell (live reload, no packaging)"
+
+      option :port,      default: "3000", desc: "Dev server port"
+      option :shell_dir, default: nil,    desc: "Path to the shell's src-tauri directory"
+
+      def call(port: "3000", shell_dir: nil, **)
+        framework = Framework.detect
+        config = Everywhere::Config.load(framework.root)
+        shell_dir ||= find_shell_dir
+
+        server_pid = nil
+        if port_open?(port)
+          UI.warn "something is ALREADY RUNNING on port #{port} — attaching to it instead of starting"
+          UI.warn "#{UI.dim("your Procfile.dev/watchers are NOT running; stop that server or use --port if this isn't yours")}"
+        else
+          UI.step("starting #{UI.bold(framework.name)} dev server #{UI.dim("(" + framework.dev_command + ")")}")
+          server_pid = Shellout.spawn({ "PORT" => port.to_s }, framework.dev_command, chdir: framework.root)
+          wait_for_port(port)
+        end
+
+        dev_url = "http://127.0.0.1:#{port}#{config.entry_path}"
+        UI.step("opening desktop shell → #{UI.cyan(dev_url)}")
+        Shellout.run!({ "NATIVE_DEV_URL" => dev_url, "NATIVE_CONFIG" => config.to_shell_json },
+                      "cargo", "run", chdir: shell_dir)
+      ensure
+        if server_pid
+          Process.kill("TERM", -Process.getpgid(server_pid)) rescue Process.kill("TERM", server_pid) rescue nil
+          Process.wait(server_pid) rescue nil
+        end
+      end
+
+      private
+
+      def find_shell_dir
+        candidates = ["shell/src-tauri", "../shell/src-tauri", "src-tauri"]
+        found = candidates.find { |c| File.exist?(File.join(c, "tauri.conf.json")) }
+        found or UI.die!("couldn't find the shell (looked in #{candidates.join(", ")}); pass --shell-dir")
+      end
+
+      def port_open?(port)
+        TCPSocket.new("127.0.0.1", Integer(port)).close
+        true
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT
+        false
+      end
+
+      def wait_for_port(port, timeout: 60)
+        deadline = Time.now + timeout
+        sleep 0.5 until port_open?(port) || Time.now > deadline
+        UI.die!("dev server never came up on port #{port}") unless port_open?(port)
+      end
+    end
+  end
+end

data/lib/everywhere/commands/doctor.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require_relative "../shellout"
+
+module Everywhere
+  module Commands
+    # Check that this machine can build desktop apps.
+    class Doctor < Dry::CLI::Command
+      desc "Check the toolchain (tebako, rust, brew deps, Xcode 26 shims)"
+
+      def call(**)
+        ok = true
+        ok &= check("rbe-tebako installed") { Shellout.run?("rbe-tebako help > /dev/null 2>&1") }
+        ok &= check("cargo installed")    { Shellout.run?("cargo --version > /dev/null 2>&1") }
+        ok &= check("homebrew bison")     { !`brew --prefix bison 2>/dev/null`.strip.empty? }
+
+        if RUBY_PLATFORM.include?("darwin") && clang_major >= 21
+          ok &= check("Xcode #{clang_major} CXX shim (~/.tebako-shims/clang++)") do
+            File.executable?(File.expand_path("~/.tebako-shims/clang++"))
+          end
+          ok &= check("tebako force_ruby_platform patch") do
+            helper = `gem contents rbe-tebako 2>/dev/null`.lines.map(&:strip).find { |l| l.end_with?("deploy_helper.rb") }
+            helper.nil? || File.read(helper).include?(%(@force_ruby_platform = "true"
+      @nokogiri_option = "--no-use-system-libraries"))
+          end
+          ok &= check("tebako rbconfig warnflags patch") do
+            stash = Dir[File.expand_path("~/.tebako/deps/stash_*/lib/ruby/*/**/rbconfig.rb")]
+            stash.empty? || stash.all? { |f| File.read(f).include?("default-const-init") }
+          end
+        end
+
+        puts
+        ok ? UI.success("ready to build") : UI.bad("fix the items above (see project docs / memory for recipes)")
+        exit(1) unless ok
+      end
+
+      private
+
+      def check(label)
+        passed = yield
+        passed ? UI.ok(label) : UI.bad(label)
+        passed
+      rescue StandardError
+        UI.bad(label)
+        false
+      end
+
+      def clang_major
+        @clang_major ||= `clang --version 2>/dev/null`[/version (\d+)/, 1].to_i
+      end
+    end
+  end
+end