ruby_native 0.17.3 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c51153c763a49fbf4d88fa288adcfe46ef69402685a9ccc8ccdf9bfe9b35da8
-  data.tar.gz: 624eb747e1fccc0bf7e14d7b4a96822ea98fbd69ff9902cca01920e29997ac28
+  metadata.gz: 6943c548d9910886fefa4a121b493c1cdc40b06ab34059c4deac3fac3ac86018
+  data.tar.gz: def52388edde0250a098f4ffa4c02e0fe691d7aa0383b1049c2ac1c178be559b
 SHA512:
-  metadata.gz: a4fe11e26a297f5ce16e995ad2892c5da65ba14b9703e0ea1c5f6bf1659bb43f3dfb18cdee60667159e71c8f4ca56dc44f8f7a731ce292f41416e15c46355525
-  data.tar.gz: 8d71d20c92e2a9203d2948df069ea4ed1fb6b20e6f76a13e38bcd67dfbd860c4982829f21fba5f2102cf145cc60bf97397d348c7ce5da2ad65de5b96ea1d93a7
+  metadata.gz: 7bdaecaa1892409cfdde1f9e6f7161acd430065e470c35a73e95a25ace1bad76f303802226952965fa8e109b8848ee4fc42c6a6db3fefb5bc0b691140b705bb1
+  data.tar.gz: b67256819c46021c2de3e11e89fa5d6c7acc51064256913d5c9e5b44ebec3184c9b0b68e9461e0d4141246c32f0363da6f423fb306781287d78f3d04b23982bd

data/README.md

@@ -18,7 +18,13 @@ Run the install generator:
 rails generate ruby_native:install
 ```
 
-This creates `config/ruby_native.yml`. Then:
+This creates `config/ruby_native.yml` with tabs taken from your routes. If you use a coding agent, hand it the rest here:
+
+```bash
+bundle exec ruby_native mcp install
+```
+
+Then say: set up Ruby Native in this app. It wires the layout, checks its own work, and later drafts the listing, captures screenshots, and submits for review, stopping only for the few clicks Apple keeps for a person. By hand, the same steps are:
 
 1. Edit the config with your colors and tabs (see below).
 2. Add the stylesheet and `viewport-fit=cover` to your layout `<head>`:
@@ -84,6 +90,52 @@ Building with Inertia instead of ERB? `@ruby-native/react` and `@ruby-native/vue
 
 Every docs page serves markdown: append `.md` to the URL or request `Accept: text/markdown`. For an index of everything, fetch [rubynative.com/llms.txt](https://rubynative.com/llms.txt), or [llms-full.txt](https://rubynative.com/llms-full.txt) for the complete docs as a single file.
 
+### MCP server
+
+Docs tell an agent what to write. They don't tell it whether what it wrote works, and Ruby Native's signals fail silently on purpose: an app that doesn't recognize a `data-native-*` attribute ignores it. A typo renders nothing, raises nothing, and logs nothing, so it survives right up until someone opens the build and notices the missing button.
+
+`ruby_native mcp` closes that loop. It speaks [MCP](https://modelcontextprotocol.io) over stdin and stdout. Three tools answer from your working copy, with no account involved:
+
+| Tool | Answers |
+|---|---|
+| `check_views` | Which signals in your templates are misspelled, duplicated, or newer than the installed gem |
+| `lookup_signals` | Every `data-native-*` attribute, the gem version it needs, and the helper that emits it |
+| `validate_config` | What in `config/ruby_native.yml` the apps reject outright, and what they quietly ignore |
+
+Four more read your account, using the token `ruby_native login` already stored:
+
+| Tool | Answers |
+|---|---|
+| `status` | Where the app is on the way to the App Store, and what is in the way, with who clears each thing |
+| `config_errors` | What real devices reported failing over the last 48 hours, with the decode error behind each one |
+| `deployed_builds` | The build your users can actually install, and which signals it's too old to understand |
+| `build_status` | Whether one build succeeded, and the error if it didn't |
+
+The pairs are the point. `validate_config` says what *will* fail to decode; `config_errors` says what did, on which devices. `check_views` compares your templates against the gem in your Gemfile; `deployed_builds` compares them against the binary in the store, which is usually the answer to "the attribute is right but nothing happens on my phone".
+
+Full reference at [rubynative.com/docs/cli](https://rubynative.com/docs/cli#mcp-server). Register it in the project's `.mcp.json`, which Claude Code reads:
+
+```bash
+bundle exec ruby_native mcp install
+```
+
+Then say: set up Ruby Native in this app.
+
+Or, in a client that takes JSON:
+
+```json
+{
+  "mcpServers": {
+    "ruby-native": {
+      "command": "bundle",
+      "args": ["exec", "ruby_native", "mcp"]
+    }
+  }
+}
+```
+
+The rest stage things with Ruby Native and reach Apple only on a build or a click on the dashboard: `permissions_set`, `testers_add`, `icon_set`, `screenshots_setup`, `screenshots_capture`, `listing_push`, `listing_pull`, and `demo_account_set`, each the same as its CLI command. `submit` is the one tool that reaches Apple on its own: it takes two calls with a token in between, so the agent has to show you what is going before it can send it, and `withdraw` takes it back out of the queue until Apple approves. The first three tools never leave your machine; the rest send your CLI token to rubynative.com. `check_views` needs the `herb` gem, same as `ruby_native check`.
+
 ## License
 
 MIT.

data/lib/generators/ruby_native/install_generator.rb

@@ -5,7 +5,44 @@ module RubyNative
 
       desc "Creates a Ruby Native config file at config/ruby_native.yml"
 
+      # The tab bar only appears with two or more tabs (the shell hides it
+      # otherwise), and a tab pointing at a path the app does not route 404s
+      # on first launch. Both failures land in the first five minutes, so tabs
+      # come from the app's own routes, and only from routes that exist.
+      MAX_TABS = 4
+
+      # Route segments that are never a tab: auth, framework, and Ruby Native's
+      # own mounts.
+      SKIPPED_SEGMENTS = %w[
+        rails up cable native assets manifest service-worker pwa admin api webhooks
+        session sessions sign_in sign_up signin signup login logout password passwords
+        registration registrations users auth oauth
+      ].freeze
+
+      TAB_ICONS = {
+        "" => "house",
+        "home" => "house",
+        "dashboard" => "house",
+        "profile" => "person",
+        "account" => "person",
+        "me" => "person",
+        "settings" => "gear",
+        "preferences" => "gear",
+        "inbox" => "envelope",
+        "messages" => "envelope",
+        "notifications" => "bell",
+        "search" => "magnifyingglass",
+        "calendar" => "calendar",
+        "events" => "calendar",
+        "orders" => "shippingbox",
+        "favorites" => "star",
+        "bookmarks" => "star"
+      }.freeze
+
+      DEFAULT_ICON = "list.bullet".freeze
+
       def copy_config
+        @tabs = proposed_tabs
         template "ruby_native.yml", "config/ruby_native.yml"
       end
 
@@ -41,23 +78,79 @@ module RubyNative
 
       def print_next_steps
         say ""
-        say "Ruby Native installed! Next steps:", :green
+        say "Ruby Native installed.", :green
+        say ""
+        say "  Tabs, from your routes: #{@tabs.map { |tab| "#{tab[:path]} (#{tab[:title]})" }.join(", ")}"
+        if @tabs.size < 2
+          say "  The tab bar stays hidden until config/ruby_native.yml has a second tab.", :yellow
+        else
+          say "  Change them in config/ruby_native.yml."
+        end
         say ""
-        say "  1. Edit config/ruby_native.yml with your app name, colors, and tabs"
-        say "  2. Add to your layout <head>:"
-        say "       <%= stylesheet_link_tag :ruby_native %>"
-        say "  3. Add viewport-fit=cover to your viewport meta tag:"
-        say "       <meta name=\"viewport\" content=\"width=device-width,initial-scale=1,viewport-fit=cover\">"
-        say "  4. Add to your layout <body>:"
-        say "       <%= native_tabs_tag %>"
-        say "       <%= native_identity_tag(current_user&.id) %>"
-        say "  5. Preview on your device:"
-        say "       bundle exec ruby_native preview"
+        say "By hand:"
+        say "  1. Add <%= stylesheet_link_tag :ruby_native %> to your layout <head>"
+        say "  2. Add viewport-fit=cover to your viewport meta tag"
+        say "  3. Add <%= native_tabs_tag %> and <%= native_identity_tag(current_user&.id) %> to your layout <body>"
+        say "  4. Preview on your phone: bundle exec ruby_native preview"
         say ""
         say "  Docs: https://rubynative.com/docs"
-        say "  AI agents: fetch https://rubynative.com/llms.txt for a docs index,"
-        say "  or https://rubynative.com/llms-full.txt for the full docs as plain text."
+        say "  Agents: https://rubynative.com/llms.txt for a docs index, llms-full.txt for all of it as plain text"
         say ""
+        say "Or hand it to your agent:", :green
+        say ""
+        say "    bundle exec ruby_native mcp install"
+        say ""
+        say "Then, in your agent: /mcp__ruby-native__ship"
+        say ""
+      end
+
+      private
+
+      def proposed_tabs
+        paths = routable_paths
+        paths = [ "/" ] if paths.empty?
+
+        paths.first(MAX_TABS).map do |path|
+          segment = path.delete_prefix("/")
+          { title: title_for(segment), path: path, icon: TAB_ICONS.fetch(segment, DEFAULT_ICON) }
+        end
+      end
+
+      # Routes a library draws into the app for its own use. Turbo's
+      # historical-location routes and the PWA manifest are GET, static, and
+      # one segment, so without this a fresh app's tabs were three Turbo
+      # internals.
+      LIBRARY_CONTROLLERS = %r{\A(turbo|rails|active_storage|action_mailbox|action_cable|action_text)/}
+
+      # Static, single-segment GET routes, root first, in the order the routes
+      # file declares them. Anything with a parameter, a glob, or a second
+      # segment is a page you reach from a tab, not a tab.
+      def routable_paths
+        paths = Rails.application.routes.routes.filter_map do |route|
+          next if route.respond_to?(:internal) && route.internal
+          next unless route.verb.to_s.match?(/\bGET\b/)
+          next if route.defaults[:controller].to_s.match?(LIBRARY_CONTROLLERS)
+
+          path = route.path.spec.to_s.sub(/\(\.:format\)\z/, "")
+          next unless path.start_with?("/")
+          next if path.match?(/[:*]/)
+
+          segments = path.delete_prefix("/").split("/")
+          next if segments.size > 1
+          next if SKIPPED_SEGMENTS.include?(segments.first)
+
+          path
+        end.uniq
+
+        paths.partition { |path| path == "/" }.flatten
+      rescue StandardError
+        []
+      end
+
+      def title_for(segment)
+        return "Home" if segment.empty?
+
+        segment.tr("_-", "  ").split.map(&:capitalize).join(" ")
       end
     end
   end

data/lib/generators/ruby_native/templates/ruby_native.yml

@@ -93,12 +93,11 @@ appearance:
 tabs:
   # Icons are SF Symbols on iOS and Material Icons on Android.
   # https://rubynative.com/docs/icons
-  - title: Home
-    path: /
-    icon: house
-  - title: Profile
-    path: /profile
-    icon: person
+<% @tabs.each do |tab| -%>
+  - title: <%= tab[:title] %>
+    path: <%= tab[:path] %>
+    icon: <%= tab[:icon] %>
+<% end -%>
 
   # Per-tab options (add to any tab above):
   #
@@ -145,7 +144,7 @@ tabs:
 #   team_id: ABCD123456
 # android:
 #   package: com.example.myapp
-#   # Play Console -> Setup -> App integrity -> App signing key certificate.
+#   # Google Play Console -> Setup -> App integrity -> App signing key certificate.
 #   cert_fingerprint: "AA:BB:CC:..."
 
 # Link only these path prefixes instead of the whole domain. Links outside

data/lib/ruby_native/cli/apple.rb

@@ -0,0 +1,76 @@
+require "ruby_native/cli/command"
+
+module RubyNative
+  class CLI
+    # The App Store Connect key. Only a person can mint it, in App Store
+    # Connect; this is how they hand it over without opening the dashboard.
+    # The file is read here and sent once; nothing reads it back, and the
+    # MCP tool takes a path for the same reason, so an agent never holds the
+    # key itself.
+    class Apple < Command
+      POLL_INTERVAL = 2
+      MAX_WAIT = 90
+
+      USAGE = "Usage: ruby_native apple key <path/to/AuthKey.p8> --key-id=KEY --issuer-id=ISSUER --team-id=TEAM".freeze
+
+      def run
+        ensure_authenticated!
+        app_id = app_id!
+
+        unless positional.first == "key" && positional[1] && flag("key-id") && flag("issuer-id") && flag("team-id")
+          puts USAGE
+          exit 1
+        end
+
+        finish(self.class.set_key(app_id, path: positional[1], key_id: flag("key-id"), issuer_id: flag("issuer-id"), team_id: flag("team-id")))
+      end
+
+      def self.set_key(app_id, path:, key_id:, issuer_id:, team_id:, wait: MAX_WAIT)
+        return Outcome.new(ok: false, text: "No file at #{path}.", data: {}) unless File.file?(path)
+
+        result = Mcp::Platform.patch("/api/v1/apps/#{app_id}/credentials",
+          { team_id: team_id, asc_key_id: key_id, asc_issuer_id: issuer_id, asc_key: File.read(path).strip })
+        return failure(result) unless result.ok?
+
+        settle(app_id, wait: wait)
+      end
+
+      # Validation runs against Apple in the background. Wait for it here,
+      # because "sent" is not the answer anybody wants; "Apple took it" is.
+      def self.settle(app_id, wait:)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + wait
+
+        loop do
+          result = Mcp::Platform.get("/api/v1/apps/#{app_id}/credentials")
+          return failure(result) unless result.ok?
+
+          state = result.value.is_a?(Hash) ? result.value : {}
+          case state["state"]
+          when "passed"
+            return success("Key verified: a Team key with the Admin role, and your agreements are signed. Ruby Native can sign and ship this app.", state)
+          when "failed"
+            return Outcome.new(ok: false, text: "Apple rejected the key: #{state["error"]}", data: state)
+          end
+
+          if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+            return success("Still checking the key with Apple. Read `ruby_native status` in a minute; it says when the key checks out.", state)
+          end
+
+          pause
+        end
+      end
+
+      # Two seconds between reads, and none in a test.
+      def self.pause
+        sleep POLL_INTERVAL unless @sleepless
+      end
+
+      def self.stub_const_sleep
+        @sleepless = true
+        yield
+      ensure
+        @sleepless = false
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/check.rb

@@ -30,7 +30,43 @@ module RubyNative
 
         check = new([], paths: paths)
 
-        check.send(:template_files).flat_map { |file| check.send(:check_file, file) }
+        template_files(paths: paths).flat_map { |file| check.send(:check_file, file) }
+      end
+
+      # The templates a run covers. Public so a caller can count them without
+      # running the checks, and so there is one definition of what gets scanned.
+      def self.template_files(paths: DEFAULT_PATHS)
+        paths.flat_map { |path| Dir.glob(File.join(path, "**", "*.html.erb")) }.sort
+      end
+
+      # The report `run` prints, as lines, so another front end renders
+      # offenses the way the CLI does instead of inventing a second format.
+      def self.report_lines(files, offenses)
+        lines = []
+
+        offenses.group_by(&:file).sort.each do |file, file_offenses|
+          lines << file
+          file_offenses.sort_by(&:line).each do |offense|
+            location = "#{offense.line}:".ljust(5)
+            marker = offense.severity.to_s.ljust(8)
+            lines << "  #{location}#{marker}#{offense.message}"
+          end
+          lines << ""
+        end
+
+        lines << summary_line(files, offenses)
+      end
+
+      def self.summary_line(files, offenses)
+        errors, warnings = offenses.partition { |offense| offense.severity == :error }
+        summary = "Checked #{files.size} #{files.size == 1 ? "template" : "templates"}"
+
+        if offenses.empty?
+          "#{summary}. No problems found."
+        else
+          "#{summary}: #{errors.size} #{errors.size == 1 ? "error" : "errors"}, " \
+            "#{warnings.size} #{warnings.size == 1 ? "warning" : "warnings"}."
+        end
       end
 
       def self.herb_available?
@@ -79,7 +115,7 @@ module RubyNative
       end
 
       def template_files
-        @paths.flat_map { |path| Dir.glob(File.join(path, "**", "*.html.erb")) }.sort
+        self.class.template_files(paths: @paths)
       end
 
       # --- Per-file checks ---
@@ -158,7 +194,11 @@ module RubyNative
         end
 
         used = signals_in(files)
-        PLATFORMS.flat_map { |platform| deployed_offenses_for(platform, app_id, used) }
+        offenses = PLATFORMS.flat_map { |platform| deployed_offenses_for(platform, app_id, used) }
+        if (scan = Permissions.scan_without_camera(app_id))
+          offenses << Offense.new(file: scan[0], line: scan[1], severity: :warning, message: Permissions.scan_without_camera_message(*scan).sub(/\A\S+ /, ""))
+        end
+        offenses
       end
 
       def deployed_offenses_for(platform, app_id, used)
@@ -222,25 +262,7 @@ module RubyNative
       # --- Reporting ---
 
       def report(files, offenses)
-        errors, warnings = offenses.partition { |offense| offense.severity == :error }
-
-        offenses.group_by(&:file).sort.each do |file, file_offenses|
-          puts file
-          file_offenses.sort_by(&:line).each do |offense|
-            location = "#{offense.line}:".ljust(5)
-            marker = offense.severity.to_s.ljust(8)
-            puts "  #{location}#{marker}#{offense.message}"
-          end
-          puts ""
-        end
-
-        summary = "Checked #{files.size} #{files.size == 1 ? "template" : "templates"}"
-        if offenses.empty?
-          puts "#{summary}. No problems found."
-        else
-          puts "#{summary}: #{errors.size} #{errors.size == 1 ? "error" : "errors"}, " \
-               "#{warnings.size} #{warnings.size == 1 ? "warning" : "warnings"}."
-        end
+        puts self.class.report_lines(files, offenses)
       end
 
       def parse_paths(argv)

data/lib/ruby_native/cli/command.rb

@@ -0,0 +1,94 @@
+require "ruby_native/cli/credentials"
+require "ruby_native/cli/mcp/platform"
+require "ruby_native/cli/status"
+
+module RubyNative
+  class CLI
+    # What every command that talks to rubynative.com about one app shares:
+    # finding the app, being logged in, and turning a refusal into something a
+    # person can act on. The MCP server calls the same `perform` methods, so a
+    # verb is a CLI command first and a tool second, and both say one thing.
+    class Command
+      Outcome = Struct.new(:ok, :text, :data, keyword_init: true)
+
+      def initialize(argv = [])
+        @argv = argv
+      end
+
+      private
+
+      def app_id!
+        flag = @argv.find { |arg| arg.start_with?("--app=") }
+        app_id = flag ? flag.split("=", 2).last : Mcp::Platform.app_id
+        return app_id unless app_id.to_s.strip.empty?
+
+        puts Mcp::Platform::NO_APP_ID
+        exit 1
+      end
+
+      def ensure_authenticated!
+        return if Credentials.token
+
+        puts Mcp::Platform::NOT_LOGGED_IN
+        exit 1
+      end
+
+      def finish(outcome)
+        puts outcome.text
+        exit 1 unless outcome.ok
+      end
+
+      PLATFORM_LABELS = { "ios" => "iOS", "android" => "Android" }.freeze
+
+      # Every store the app has started, unless --ios or --android names one.
+      # A server too old to say, or an app with neither started, means iOS.
+      def platforms!(app_id)
+        return [ "android" ] if @argv.include?("--android")
+        return [ "ios" ] if @argv.include?("--ios")
+
+        status = Status.fetch(app_id)
+        started = status.ok? ? Array(status.value["platforms"]) & PLATFORM_LABELS.keys : []
+        started.empty? ? [ "ios" ] : started
+      end
+
+      # One store prints as it always has; two get a heading each, and the
+      # command fails if either did.
+      def finish_each(platforms)
+        return finish(yield(platforms.first)) if platforms.one?
+
+        outcomes = platforms.map { |platform| [ platform, yield(platform) ] }
+        puts outcomes.map { |platform, outcome| "#{PLATFORM_LABELS[platform]}:\n#{outcome.text}" }.join("\n\n")
+        exit 1 unless outcomes.all? { |_, outcome| outcome.ok }
+      end
+
+      def positional
+        @argv.reject { |arg| arg.start_with?("--") }
+      end
+
+      def flag(name)
+        value = @argv.find { |arg| arg.start_with?("--#{name}=") }
+        value&.split("=", 2)&.last
+      end
+
+      def self.failure(result)
+        lines = [ result.error ]
+        result.field_errors.each do |field, messages|
+          Array(messages).each do |message|
+            next if result.error.to_s.downcase.include?(message.to_s.downcase)
+
+            lines << "  #{field} #{message}"
+          end
+        end
+        if result.blocked_by.any?
+          lines << ""
+          lines.concat(Status.blocker_lines(result.blocked_by))
+        end
+        Outcome.new(ok: false, text: lines.join("\n").strip, data: { "error" => result.error, "blocked_by" => result.blocked_by, "errors" => result.field_errors })
+      end
+
+      def self.success(text, data)
+        Outcome.new(ok: true, text: text, data: data)
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/demo_account.rb

@@ -0,0 +1,36 @@
+require "ruby_native/cli/command"
+
+module RubyNative
+  class CLI
+    # The reviewer's sign-in, staged with rubynative.com and written to App
+    # Store Connect when the listing is published. It stays out of
+    # config/ruby_native_listing.yml on purpose: that file is committed.
+    class DemoAccount < Command
+      def run
+        ensure_authenticated!
+        app_id = app_id!
+
+        unless positional.first == "set" && flag("name")
+          puts "Usage: ruby_native demo_account set --name=EMAIL --password=SECRET [--notes=\"...\"] [--not-required]"
+          exit 1
+        end
+
+        finish(self.class.set(app_id, name: flag("name"), password: flag("password"), notes: flag("notes"), required: !@argv.include?("--not-required")))
+      end
+
+      def self.set(app_id, name:, password: nil, notes: nil, required: true)
+        demo = { name: name, required: required }
+        demo[:password] = password unless password.nil?
+        demo[:notes] = notes unless notes.nil?
+
+        result = Mcp::Platform.patch("/api/v1/apps/#{app_id}/listing", { demo_account: demo })
+        return failure(result) unless result.ok?
+
+        account = result.value["demo_account"] || {}
+        text = "Demo account #{account["name"]}#{account["password_set"] ? "" : " (no password set)"} saved. " \
+               "It reaches App Store Connect when the listing is published."
+        success(text, result.value)
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/deploy.rb

@@ -4,6 +4,8 @@ require "uri"
 require "openssl"
 require "ruby_native/cli/check"
 require "ruby_native/cli/credentials"
+require "ruby_native/cli/mcp/platform"
+require "ruby_native/cli/status"
 require "ruby_native/version"
 
 module RubyNative
@@ -34,6 +36,8 @@ module RubyNative
         @if_needed = argv.include?("--if-needed")
         @skip_check = argv.include?("--skip-check")
         @platform = parse_platform(argv)
+        @app_flag = argv.find { |arg| arg.start_with?("--app=") }&.split("=", 2)&.last
+        @version = argv.find { |arg| arg.start_with?("--version=") }&.split("=", 2)&.last
       end
 
       def run
@@ -46,7 +50,10 @@ module RubyNative
           return
         end
 
-        check_signals! unless @skip_check
+        unless @skip_check
+          check_signals!
+          warn_scan_without_camera(app_id)
+        end
 
         build = trigger_build(app_id)
         return if @if_needed
@@ -83,6 +90,17 @@ module RubyNative
         exit 1
       end
 
+      # A warning, not a stop: the build is fine, one button in it isn't.
+      def warn_scan_without_camera(app_id)
+        file, line = Permissions.scan_without_camera(app_id)
+        return unless file
+
+        puts "Heads up: #{Permissions.scan_without_camera_message(file, line)}"
+        puts
+      rescue StandardError
+        nil
+      end
+
       def ensure_authenticated!
         return if Credentials.token
 
@@ -145,7 +163,7 @@ module RubyNative
       end
 
       def resolve_app_id!
-        app_id = @config.dig(:ruby_native, :app_id)
+        app_id = (@app_flag unless @app_flag.to_s.strip.empty?) || @config.dig(:ruby_native, :app_id)
         app_id = link_app unless app_id
         unless app_id
           puts "No app selected. Run `ruby_native deploy` again."
@@ -244,6 +262,7 @@ module RubyNative
         when Net::HTTPUnprocessableEntity
           data = parse_json(response)
           puts "Cannot build: #{data&.dig("error") || "the server rejected the request (422)."}"
+          print_blockers(data)
           exit 1
         when Net::HTTPNotFound
           puts "The app linked in config/ruby_native.yml was not found on your account."
@@ -419,6 +438,16 @@ module RubyNative
 
       # Server-provided warnings (a lapsed payment, say) reach customers with
       # no gem release. Deduped, since every status poll repeats the string.
+      # A refusal names what is in the way and who clears it, the same list the
+      # dashboard shows. An older server sends only the sentence.
+      def print_blockers(data)
+        blockers = data.is_a?(Hash) ? data["blocked_by"] : nil
+        return unless blockers.is_a?(Array) && blockers.any?
+
+        puts ""
+        puts Status.blocker_lines(blockers)
+      end
+
       def print_notice(data)
         notice = data["notice"]
         return unless notice.is_a?(String) && !notice.strip.empty?
@@ -483,6 +512,7 @@ module RubyNative
       def build_payload
         payload = { gem_version: RubyNative::VERSION }
         payload[:platform] = @platform unless @platform == "ios"
+        payload[:version] = @version if @version && !@version.empty?
         payload
       end
 
@@ -538,16 +568,7 @@ module RubyNative
       end
 
       def write_app_id_to_config(app_id)
-        raw = File.read(CONFIG_PATH)
-
-        if raw.match?(/^ruby_native:/)
-          raw = raw.gsub(/^(ruby_native:\s*\n)/, "\\1  app_id: #{app_id}\n")
-        else
-          raw = raw.rstrip + "\n\nruby_native:\n  app_id: #{app_id}\n"
-        end
-
-        File.write(CONFIG_PATH, raw)
-
+        Mcp::Platform.write_app_id(app_id, CONFIG_PATH)
         @config = read_config
       end