ruby_native 0.17.2 → 0.18.0

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
 

data/lib/ruby_native/cli/icon.rb

@@ -0,0 +1,29 @@
+require "ruby_native/cli/command"
+
+module RubyNative
+  class CLI
+    # The app icon: a 1024x1024 PNG with no transparency. It goes in the asset
+    # catalog, so a new one ships with the next build.
+    class Icon < Command
+      def run
+        ensure_authenticated!
+        app_id = app_id!
+
+        unless positional.first == "set" && positional[1]
+          puts "Usage: ruby_native icon set <path/to/icon.png>"
+          exit 1
+        end
+        finish(self.class.set(app_id, positional[1]))
+      end
+
+      def self.set(app_id, path)
+        return Outcome.new(ok: false, text: "No file at #{path}.", data: {}) unless File.file?(path)
+
+        result = Mcp::Platform.put_file("/api/v1/apps/#{app_id}/icon", field: "icon", file: path, content_type: "image/png")
+        return failure(result) unless result.ok?
+
+        success("Icon set from #{path}. #{result.value["note"]}", result.value)
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/link.rb

@@ -0,0 +1,40 @@
+require "ruby_native/cli/command"
+require "ruby_native/cli/mcp/platform"
+
+module RubyNative
+  class CLI
+    # Links this project to an app on rubynative.com by writing
+    # `ruby_native.app_id` into config/ruby_native.yml. Every command that
+    # talks to rubynative.com reads it from there. Deploy used to be the only
+    # way to link, which put the first honest status read behind a build.
+    class Link < Command
+      def run
+        ensure_authenticated!
+        finish(self.class.link(positional.first || flag("app")))
+      end
+
+      def self.link(app_id = nil)
+        result = Mcp::Platform.get("/api/v1/apps")
+        return failure(result) unless result.ok?
+
+        apps = Array(result.value)
+        return Outcome.new(ok: false, text: "No apps on this account yet. Create one at #{Mcp::Platform::HOST}/apps/new, then run this again.", data: { "apps" => [] }) if apps.empty?
+
+        app = if app_id.to_s.strip.empty?
+          apps.one? ? apps.first : nil
+        else
+          apps.find { |candidate| candidate["public_id"] == app_id.to_s.strip }
+        end
+
+        unless app
+          lines = [ app_id ? "No app #{app_id.inspect} on this account. Pick one:" : "Which app? Run `ruby_native link APP_ID` with one of these:" ]
+          apps.each { |candidate| lines << "  #{candidate["public_id"]}  #{candidate["name"]}#{"  (#{candidate["url"]})" if candidate["url"]}" }
+          return Outcome.new(ok: false, text: lines.join("\n"), data: { "apps" => apps })
+        end
+
+        Mcp::Platform.write_app_id(app["public_id"])
+        success("Linked to #{app["name"]} (#{app["public_id"]}). Wrote ruby_native.app_id to #{Mcp::Platform::CONFIG_PATH}.", { "app_id" => app["public_id"], "name" => app["name"] })
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/listing.rb

@@ -0,0 +1,236 @@
+require "erb"
+require "yaml"
+require "ruby_native/cli/command"
+
+module RubyNative
+  class CLI
+    # The App Store listing, written in config/ruby_native_listing.yml and
+    # staged with rubynative.com. `push` stops there. `publish` is a different
+    # verb on purpose: the agent prompt names `push`, so following it can never
+    # put words on the store, and someone shipping from a terminal types the
+    # same act as pressing the button.
+    class Listing < Command
+      PATH = "config/ruby_native_listing.yml".freeze
+      FIELDS = %w[name subtitle primary_category secondary_category keywords whats_new privacy_policy_url support_url support_email website copyright description].freeze
+      CONTACT_FIELDS = %w[first_name last_name email phone].freeze
+      LIMITS = { "name" => 30, "subtitle" => 30, "keywords" => 100, "whats_new" => 4000, "description" => 4000 }.freeze
+      # An `ios:` or `android:` block replaces these for one store: Apple
+      # refuses a listing that mentions Android, and Play's short description
+      # (the subtitle) has 80 characters. The rest is Apple's alone.
+      STORE_FIELDS = %w[name subtitle description whats_new].freeze
+      BLOCK_FIELDS = %w[description whats_new].freeze
+      PLAY_LIMITS = { "name" => 30, "subtitle" => 80, "description" => 4000, "whats_new" => 500 }.freeze
+      STORES = { "ios" => "the App Store", "android" => "Google Play" }.freeze
+
+      def run
+        ensure_authenticated!
+        app_id = app_id!
+
+        case positional.first
+        when "push" then finish(self.class.push(app_id))
+        when "pull" then finish(self.class.pull(app_id))
+        when "publish" then publish_each(app_id)
+        when "revert" then finish(self.class.revert(app_id, positional.drop(1), platform: @argv.include?("--android") ? "android" : "ios"))
+        else
+          puts "Usage: ruby_native listing <push|pull|publish|revert FIELD...> [--ios|--android]"
+          puts "  push       Save #{PATH} to Ruby Native. Nothing reaches a store."
+          puts "  pull       Write #{PATH} from what Ruby Native holds."
+          puts "  publish    Push, then send the listing to every store the app has started."
+          puts "  revert     Take App Store Connect's words (Google Play Console's with --android) for each field named."
+          puts "  --ios      Publish to App Store Connect only."
+          puts "  --android  Publish the title and descriptions to Google Play only."
+          exit 1
+        end
+      end
+
+      # One push, then each store.
+      def publish_each(app_id)
+        pushed = self.class.push(app_id)
+        return finish(pushed) unless pushed.ok
+
+        adopted = self.class.store_lines(pushed.data.merge("conflicts" => []))
+        puts adopted.join("\n") if adopted.any?
+        finish_each(platforms!(app_id)) { |platform| self.class.send_to_store(app_id, platform) }
+      end
+
+      def self.push(app_id)
+        listing = read_file
+        return listing if listing.is_a?(Outcome)
+
+        problems = over_limits(listing)
+        return Outcome.new(ok: false, text: ([ "#{PATH} has fields over the stores' limits:" ] + problems).join("\n"), data: { "errors" => problems }) if problems.any?
+
+        contact = listing.delete("review_contact")
+        body = { listing: listing }
+        body[:review_contact] = contact if contact&.any?
+        result = Mcp::Platform.patch("/api/v1/apps/#{app_id}/listing", body)
+        return failure(result) unless result.ok?
+
+        changed = Array(result.value["changed"])
+        lines = [ changed.empty? ? "Nothing changed." : "Saved #{changed.join(", ")}." ]
+        missing = Array(result.value["missing"])
+        lines << "Still missing before it can be submitted: #{missing.join(", ")}." if missing.any?
+        lines.concat(store_lines(result.value))
+        lines << "Nothing has reached Apple. `ruby_native listing publish` sends it, or publish from the dashboard."
+        success(lines.join("\n"), result.value)
+      end
+
+      def self.revert(app_id, fields, platform: "ios")
+        return Outcome.new(ok: false, text: "Name the fields to revert, like `ruby_native listing revert name subtitle`.", data: {}) if fields.empty?
+
+        body = { revert: fields }
+        body[:platform] = "android" if platform == "android"
+        result = Mcp::Platform.patch("/api/v1/apps/#{app_id}/listing", body)
+        return failure(result) unless result.ok?
+
+        store = platform == "android" ? "Google Play Console" : "App Store Connect"
+        success("Took #{store}'s #{fields.map { |field| field.tr("_", " ") }.join(", ")}. Run `ruby_native listing pull` so #{PATH} has it too, or the next push sends yours again.", result.value)
+      end
+
+      # What reading the stores found: words someone changed there that Ruby Native took, and fields both sides changed.
+      # A server too old to read the stores sends neither.
+      def self.store_lines(value)
+        lines = []
+        adopted = Array(value["adopted"])
+        if adopted.any?
+          lines << "Took #{adopted.map { |row| "#{store_name(row)}'s #{row["field"].to_s.tr("_", " ")}" }.join(", ")}, changed there since the last publish. " \
+                   "Run `ruby_native listing pull` so #{PATH} has it."
+        end
+        Array(value["conflicts"]).each do |row|
+          flag = row["platform"] == "android" ? " --android" : ""
+          lines << "#{store_name(row)} has a different #{row["field"].to_s.tr("_", " ")}: #{row["store"].to_s.inspect}. Publishing sends yours over it; " \
+                   "`ruby_native listing revert #{row["field"]}#{flag}` takes #{store_name(row)}'s."
+        end
+        lines
+      end
+
+      def self.store_name(row) = row["platform"] == "android" ? "Google Play Console" : "App Store Connect"
+
+      def self.pull(app_id)
+        result = Mcp::Platform.get("/api/v1/apps/#{app_id}/listing")
+        return failure(result) unless result.ok?
+
+        listing = (result.value["listing"] || {}).merge("review_contact" => result.value["review_contact"] || {})
+        File.write(PATH, render(listing))
+        success("Wrote #{PATH} from the listing Ruby Native holds.", result.value)
+      end
+
+      def self.publish(app_id, platform: "ios")
+        pushed = push(app_id)
+        return pushed unless pushed.ok
+
+        send_to_store(app_id, platform)
+      end
+
+      def self.send_to_store(app_id, platform)
+        result = Mcp::Platform.post("/api/v1/apps/#{app_id}/listing/publish", platform == "android" ? { platform: "android" } : nil)
+        return failure(result) unless result.ok?
+
+        success(result.value["note"].to_s, result.value)
+      end
+
+      # ERB first so a description can interpolate, then YAML. Only known
+      # keys go up; anything else in the file is left alone and reported.
+      def self.read_file
+        return Outcome.new(ok: false, text: "No #{PATH}. Run `ruby_native listing pull` to start one from the dashboard's draft, or write it by hand.", data: {}) unless File.exist?(PATH)
+
+        data = YAML.safe_load(ERB.new(File.read(PATH, encoding: "UTF-8")).result, aliases: true)
+        return Outcome.new(ok: false, text: "#{PATH} has to be a YAML mapping of listing fields.", data: {}) unless data.is_a?(Hash)
+
+        # An empty line from the template is a field not written yet, not a
+        # request to blank it.
+        listing = data.slice(*FIELDS).compact.transform_values { |value| value.to_s.strip }
+        # Every push sends both blocks, so one deleted from the file stops overriding.
+        STORES.each_key do |store|
+          block = data[store] || {}
+          return Outcome.new(ok: false, text: "#{store}: in #{PATH} has to be a mapping of #{STORE_FIELDS.join(", ")}.", data: {}) unless block.is_a?(Hash)
+
+          shared = block.keys.map(&:to_s) - STORE_FIELDS
+          return Outcome.new(ok: false, text: "#{store}: in #{PATH} can only set #{STORE_FIELDS.join(", ")}; #{shared.join(", ")} #{shared.one? ? "is" : "are"} shared by every store.", data: {}) if shared.any?
+
+          listing[store] = block.transform_keys(&:to_s).compact.transform_values { |value| value.to_s.strip }.reject { |_, value| value.empty? }
+        end
+        contact = data["review_contact"]
+        listing["review_contact"] = contact.slice(*CONTACT_FIELDS).compact.transform_values { |value| value.to_s.strip } if contact.is_a?(Hash)
+        listing
+      rescue Psych::SyntaxError => error
+        Outcome.new(ok: false, text: "#{PATH} is not valid YAML: #{error.message}", data: {})
+      end
+
+      # Checked on what each store will get: a long shared subtitle is fine
+      # when `ios:` has its own.
+      def self.over_limits(listing)
+        { "ios" => LIMITS, "android" => PLAY_LIMITS }.flat_map do |store, limits|
+          own = listing[store] || {}
+          limits.filter_map do |field, limit|
+            # Shared release notes are cut to Play's 500 on the way out; only Play's own must fit.
+            next if store == "android" && field == "whats_new" && !own[field]
+
+            value = own[field] || listing[field]
+            length = value.to_s.length
+            next unless length > limit
+
+            "  #{"#{store}." if own[field]}#{field} is #{length} characters, the limit on #{STORES[store]} is #{limit}"
+          end
+        end.uniq
+      end
+
+      # Every field is written, empty ones with their limit, so a pull on an
+      # app with no listing yet is a template rather than a file of comments
+      # that push then refuses.
+      def self.render(listing)
+        lines = [ "# App Store and Google Play listing. `ruby_native listing push` saves it to Ruby Native;", "# publishing to a store is a separate step.", "" ]
+        FIELDS.each do |field|
+          lines.concat(render_contact(listing["review_contact"] || {})) if field == "description"
+          value = listing[field]
+          if value.nil? || value.to_s.empty?
+            lines << "#{field}:#{" # up to #{LIMITS[field]} characters" if LIMITS[field]}"
+            next
+          end
+
+          if BLOCK_FIELDS.include?(field)
+            lines << "#{field}: |-"
+            value.to_s.each_line { |line| lines << "  #{line.rstrip}" }
+          else
+            lines << "#{field}: #{scalar(value)}"
+          end
+        end
+        lines << ""
+        lines << "# ios: and android: replace name, subtitle, description, or whats_new for one store."
+        STORES.each_key do |store|
+          block = (listing[store] || {}).slice(*STORE_FIELDS).reject { |_, value| value.to_s.empty? }
+          next if block.empty?
+
+          lines << "#{store}:"
+          block.each do |field, value|
+            if BLOCK_FIELDS.include?(field)
+              lines << "  #{field}: |-"
+              value.to_s.each_line { |line| lines << "    #{line.rstrip}" }
+            else
+              lines << "  #{field}: #{scalar(value)}"
+            end
+          end
+        end
+        lines.join("\n") + "\n"
+      end
+
+      def self.render_contact(contact)
+        lines = [ "review_contact: # who App Review contacts; never shown on the store" ]
+        CONTACT_FIELDS.each do |field|
+          value = contact[field]
+          lines << if value.nil? || value.to_s.empty?
+            "  #{field}:#{" # \"+1 503 555 0100\", quoted" if field == "phone"}"
+          else
+            "  #{field}: #{scalar(value)}"
+          end
+        end
+        lines
+      end
+
+      # YAML reads an unquoted +15035550100 as a number and drops the +.
+      def self.scalar(value)
+        value.to_s.include?(":") || value.to_s.start_with?("#", "+") ? value.to_s.inspect : value
+      end
+    end
+  end
+end