ruby_native 0.17.3 → 0.18.0

data/lib/ruby_native/cli/permissions.rb

@@ -0,0 +1,80 @@
+require "ruby_native/cli/command"
+
+module RubyNative
+  class CLI
+    # The strings iOS shows when the app first asks for the camera, the
+    # microphone, or the photo library. They land in Info.plist, so a change
+    # ships with the next build.
+    class Permissions < Command
+      NAMES = %w[camera microphone photos].freeze
+
+      def run
+        ensure_authenticated!
+        app_id = app_id!
+
+        case positional.first
+        when "set"
+          name, text = positional[1], positional[2]
+          unless NAMES.include?(name) && text
+            puts "Usage: ruby_native permissions set <#{NAMES.join("|")}> \"<why the app asks>\""
+            exit 1
+          end
+          finish(self.class.set(app_id, name => text))
+        when "list", nil
+          finish(self.class.list(app_id))
+        else
+          puts "Unknown permissions command #{positional.first.inspect}. Use `set` or `list`."
+          exit 1
+        end
+      end
+
+      def self.list(app_id)
+        result = Mcp::Platform.get("/api/v1/apps/#{app_id}/permissions")
+        return failure(result) unless result.ok?
+
+        success(render(result.value), result.value)
+      end
+
+      def self.set(app_id, permissions)
+        unknown = permissions.keys.map(&:to_s) - NAMES
+        return Outcome.new(ok: false, text: "Unknown permission #{unknown.first.inspect}. Use #{NAMES.join(", ")}.", data: {}) if unknown.any?
+
+        result = Mcp::Platform.patch("/api/v1/apps/#{app_id}/permissions", { permissions: permissions })
+        return failure(result) unless result.ok?
+
+        changed = Array(result.value["changed"])
+        lines = [ render(result.value) ]
+        lines << ""
+        lines << (changed.empty? ? "Nothing changed." : "Changed: #{changed.join(", ")}. #{result.value["note"]}")
+        success(lines.join("\n"), result.value)
+      end
+
+      # Without a camera sentence the build has no NSCameraUsageDescription, so the
+      # native scanner refuses and a scan button does nothing. Returns where the
+      # views scan when the app has none; nil when it's fine or can't be told.
+      def self.scan_without_camera(app_id, paths: [ "app/views" ])
+        use = paths.flat_map { |path| Dir.glob(File.join(path, "**", "*.erb")) }.sort.lazy.filter_map do |file|
+          line = File.foreach(file).with_index(1).find { |text, _| text.include?("native_scan_button_tag") }&.last
+          [ file, line ] if line
+        end.first
+        return nil unless use
+
+        result = Mcp::Platform.get("/api/v1/apps/#{app_id}/permissions")
+        return nil unless result.ok?
+
+        camera = result.value.is_a?(Hash) ? result.value.dig("permissions", "camera") : nil
+        camera.to_s.strip.empty? ? use : nil
+      end
+
+      def self.scan_without_camera_message(file, line)
+        "#{file}:#{line} uses native_scan_button_tag, but the app has no camera sentence, so Scan won't open. " \
+          "Add one with `bundle exec ruby_native permissions set camera \"Why the app uses the camera\"`; it ships with the next deploy."
+      end
+
+      def self.render(value)
+        permissions = value.is_a?(Hash) ? value["permissions"] || {} : {}
+        NAMES.map { |name| "#{name.ljust(11)} #{permissions[name].to_s.empty? ? "(not set, the app cannot ask)" : permissions[name]}" }.join("\n")
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/preview.rb

@@ -335,7 +335,7 @@ module RubyNative
         puts ""
         puts "Like what you see? `ruby_native deploy` puts a real app on your phone for good."
         puts ""
-        puts "Free until you ship: #{DEPLOY_URL}"
+        puts "How it works: #{DEPLOY_URL}"
       end
 
       def trap_interrupt

data/lib/ruby_native/cli/screenshots.rb

@@ -0,0 +1,111 @@
+require "ruby_native/cli/command"
+
+module RubyNative
+  class CLI
+    # Store screenshots, captured by rubynative.com against the deployed site.
+    # Each store has its own pages; the key, one per app, is only for pages
+    # behind a sign-in. A capture is a job to follow. They reach the store
+    # with the listing: `listing publish`, or the dashboard.
+    class Screenshots < Command
+      def run
+        ensure_authenticated!
+        app_id = app_id!
+
+        case positional.first
+        when "setup"
+          paths = flag("paths").to_s.split(",").map(&:strip).reject(&:empty?)
+          finish(self.class.setup(app_id, paths: paths, platforms: (platforms!(app_id) if paths.any?),
+            sign_in: @argv.include?("--sign-in"), rotate_key: @argv.include?("--rotate-key")))
+        when "capture"
+          finish_each(platforms!(app_id)) { |platform| self.class.capture(app_id, platform: platform) }
+        when "list", nil
+          finish(self.class.list(app_id))
+        else
+          puts "Unknown screenshots command #{positional.first.inspect}. Use `setup`, `capture`, or `list`."
+          exit 1
+        end
+      end
+
+      # Sets each store's pages when given (no platforms sets both). The key is
+      # only for pages behind a sign-in: generated with sign_in when there is
+      # none, or replaced with rotate_key. It comes back once, with where to put it.
+      def self.setup(app_id, paths: [], platforms: nil, sign_in: false, rotate_key: false)
+        current = Mcp::Platform.get("/api/v1/apps/#{app_id}/screenshots")
+        return failure(current) unless current.ok?
+
+        lines = []
+        data = current.value.dup
+        if rotate_key || (sign_in && !current.value["key_configured"])
+          key = Mcp::Platform.post("/api/v1/apps/#{app_id}/screenshots/key")
+          return failure(key) unless key.ok?
+
+          data["screenshot_key"] = key.value["screenshot_key"]
+          lines << (key.value["rotated"] ? "Rotated the screenshot key. The old one stopped working." : "Generated the screenshot key.")
+          lines << ""
+          lines << "  #{key.value["screenshot_key"]}"
+          lines << ""
+          lines << "Add it to the app's Rails credentials and read it in an initializer, then deploy:"
+          lines << ""
+          lines << "  # bin/rails credentials:edit"
+          lines << "  ruby_native:"
+          lines << "    screenshot_key: <the key above>"
+          lines << ""
+          lines << "  # config/initializers/ruby_native.rb"
+          lines << "  RubyNative.configure { |c| c.screenshot_key = Rails.application.credentials.ruby_native.screenshot_key }"
+          lines << ""
+        elsif sign_in
+          lines << "The screenshot key is already set. Pass --rotate-key to replace it."
+        end
+
+        if paths.any?
+          (platforms || [ nil ]).each do |platform|
+            updated = Mcp::Platform.patch("/api/v1/apps/#{app_id}/screenshots", platform ? { paths: paths, platform: platform } : { paths: paths })
+            return failure(updated) unless updated.ok?
+
+            data = updated.value.merge(data.slice("screenshot_key"))
+          end
+          stores = (platforms || %w[ios android]).map { |platform| PLATFORM_LABELS[platform] }.join(" and ")
+          lines << "Pages to capture for #{stores}: #{paths.join(", ")}"
+        elsif Array(current.value["paths"]).empty?
+          lines << "No pages to capture yet. Run this again with --paths /,/inbox,/settings (3 to 10 pages)."
+        end
+
+        lines << "Then: `ruby_native screenshots capture`."
+        success(lines.join("\n"), data)
+      end
+
+      def self.capture(app_id, platform: "ios")
+        result = Mcp::Platform.post("/api/v1/apps/#{app_id}/screenshots/capture", { platform: platform })
+        return failure(result) unless result.ok?
+
+        capture = result.value["capture"] || {}
+        success("Capturing #{platform} screenshots (capture #{capture["id"]}). #{result.value["note"]}", result.value)
+      end
+
+      def self.list(app_id)
+        result = Mcp::Platform.get("/api/v1/apps/#{app_id}/screenshots")
+        return failure(result) unless result.ok?
+
+        value = result.value
+        lines = []
+        lines << "Sign-in key: #{value["key_configured"] ? "set" : "not set (only pages behind a sign-in need one: `ruby_native screenshots setup --sign-in`)"}"
+        pages = value["pages"] || { "ios" => value["paths"] }
+        pages.each do |platform, paths|
+          paths = Array(paths)
+          lines << "#{PLATFORM_LABELS.fetch(platform, platform)} pages: #{paths.empty? ? "none yet" : paths.join(", ")}"
+        end
+        (value["captures"] || {}).each do |platform, capture|
+          label = platform == "ios" ? "iOS" : "Android"
+          if capture.nil?
+            lines << "#{label}: no capture yet"
+          else
+            state = capture["in_progress"] ? "in progress" : capture["status"]
+            lines << "#{label}: capture #{capture["id"]} #{state}, #{capture["screenshots"]} screenshots#{capture["upload_status"] ? ", #{capture["upload_status"].tr("_", " ")}" : ""}"
+          end
+        end
+        lines << "Publish them to the stores from #{value["dashboard_url"]}." if value["dashboard_url"]
+        success(lines.join("\n"), value)
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/ship.rb

@@ -0,0 +1,16 @@
+require "ruby_native/cli/mcp/prompts"
+
+module RubyNative
+  class CLI
+    # Prints the `ship` prompt, for an agent whose client cannot show an MCP
+    # prompt as a command. Same text, pasted instead of picked.
+    class Ship
+      def initialize(_argv = [])
+      end
+
+      def run
+        puts Mcp::Prompts::SHIP
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/status.rb

@@ -0,0 +1,196 @@
+require "ruby_native/cli/credentials"
+require "ruby_native/cli/mcp/platform"
+
+module RubyNative
+  class CLI
+    # Where the app is and what is in the way, straight from the same answer
+    # the dashboard reads. The MCP `status` tool renders exactly this, so a
+    # person at a terminal and an agent see one report.
+    #
+    # A blocker names who clears it. "human" is a hand-off: the CLI prints the
+    # steps and stops, because the step is one only a person can take (pay,
+    # create the app record, answer a questionnaire Apple gives us no API for).
+    class Status
+      def initialize(argv = [])
+        @app_id = argv.find { |arg| arg.start_with?("--app=") }&.split("=", 2)&.last || argv.find { |arg| !arg.start_with?("--") }
+      end
+
+      # What the layout has to carry before the app looks like one. Read as
+      # substrings across every layout, so a helper split over lines or moved
+      # into a partial the layout renders is missed: the report says "missing"
+      # and the person can see it is not. Wrong the safe way round.
+      LAYOUT_GLOB = "app/views/layouts/**/*.html.erb".freeze
+      MARKERS = {
+        "stylesheet_link_tag :ruby_native" => "the Ruby Native stylesheet",
+        "viewport-fit=cover" => "viewport-fit=cover",
+        "native_tabs_tag" => "native_tabs_tag",
+        "native_identity_tag" => "native_identity_tag"
+      }.freeze
+
+      def run
+        app_id = @app_id || Mcp::Platform.app_id
+        if app_id.to_s.strip.empty? || Credentials.token.nil?
+          puts self.class.local_report
+          return
+        end
+
+        result = self.class.fetch(app_id)
+        unless result.ok?
+          puts self.class.failure_message(result, app_id)
+          exit 1
+        end
+
+        puts self.class.report(result.value)
+      end
+
+      def self.fetch(app_id)
+        Mcp::Platform.get("/api/v1/apps/#{app_id}")
+      end
+
+      def self.failure_message(result, app_id)
+        return result.error unless result.not_found?
+
+        "No app #{app_id.inspect} on this account. Check `ruby_native.app_id` in #{Mcp::Platform::CONFIG_PATH}, " \
+          "or pass an app id."
+      end
+
+      # --- Before an app is linked ---
+
+      # Everything `status` can know without the API: the file the generator
+      # writes, the four things the first native pass puts in the layout, and
+      # whether login and link have happened. The next step follows from which
+      # of those is missing first.
+      def self.local
+        layouts = Dir.glob(LAYOUT_GLOB).sort.map { |path| File.read(path) }.join("\n")
+
+        {
+          "local" => true,
+          "gem_version" => RubyNative::VERSION,
+          "config" => File.exist?(Mcp::Platform::CONFIG_PATH),
+          "layout" => MARKERS.keys.to_h { |marker| [ marker, layouts.include?(marker) ] },
+          "app_id" => Mcp::Platform.app_id,
+          "logged_in" => !Credentials.token.nil?
+        }
+      end
+
+      def self.local_report(local = self.local)
+        missing = local["layout"].reject { |_, present| present }.keys.map { |marker| MARKERS[marker] }
+
+        lines = [ "Ruby Native #{local["gem_version"]}, before an app is linked.", "" ]
+        lines << "  #{Mcp::Platform::CONFIG_PATH}: #{local["config"] ? "present" : "missing"}"
+        lines << "  Layout: #{missing.empty? ? "has the first native pass" : "missing #{missing.join(", ")}"}"
+        lines << "  Login: #{local["logged_in"] ? "stored" : "none"}"
+        lines << "  Linked app: #{local["app_id"] || "none"}"
+        lines << ""
+        lines << "Next: #{local_next(local, missing)}"
+        lines.join("\n")
+      end
+
+      def self.local_next(local, missing)
+        if !local["config"]
+          "run `bin/rails generate ruby_native:install`."
+        elsif missing.any?
+          "the first native pass, the seven changes in the `ship` prompt (`ruby_native ship` prints it). " \
+            "Then `bundle exec ruby_native preview` to see it on a phone."
+        elsif !local["logged_in"]
+          "create the app at #{Mcp::Platform::HOST}/apps/new (a name, the site's URL, and an account if you have none), " \
+            "then `ruby_native login` and `ruby_native link`."
+        else
+          "run `ruby_native link` to pick the app on your account."
+        end
+      end
+
+      # --- Rendering ---
+
+      def self.report(status)
+        status = status.is_a?(Hash) ? status : {}
+        ios = status["ios"] || {}
+        android = status["android"] || {}
+        subscription = status["subscription"] || {}
+
+        lines = []
+        lines << "#{status["name"]} (#{status["public_id"]}) · #{status["url"]}"
+        lines << "Dashboard: #{status["dashboard_url"]}" if status["dashboard_url"]
+        lines << ""
+        lines << "iOS: #{track_summary(ios, store: "the App Store")}"
+        lines << "Android: #{track_summary(android, store: "Google Play")}"
+        lines << "Subscription: #{subscription_summary(subscription)}"
+        lines << ""
+        lines.concat(next_lines(ios, "iOS"))
+        lines << ""
+        lines.concat(next_lines(android, "Android"))
+
+        lines.join("\n")
+      end
+
+      def self.track_summary(track, store:)
+        parts = [ track["setup"] ]
+        build = track["latest_build"]
+        parts << (build ? "build #{build["number"]} (#{build["version"]}) #{build["status"]}" : "no build yet")
+        parts << (track["live"] ? "live on #{store}" : "not on #{store}")
+        parts.compact.join(" · ")
+      end
+
+      def self.subscription_summary(subscription)
+        return "past due, builds paused" if subscription["past_due"]
+        return "none" unless subscription["active"]
+
+        subscription["plan"] ? "#{subscription["plan"]}, active" : "active"
+      end
+
+      # One track at a time: the stores gate differently, and an app can be
+      # live on one and unbuilt on the other.
+      def self.next_lines(track, label)
+        blockers = Array(track["blocked_by"])
+        act = track["next"].to_s
+        android = label == "Android"
+
+        if blockers.empty?
+          update = track["update"] || {}
+          return [ update_line(update, label, android) ] if act == "build" && update["due"]
+
+          return [ case act
+                   when "submit" then "#{label}: nothing is in the way of submitting for review. Run `bundle exec ruby_native submit`."
+                   when "wait" then "#{label}: in App Store review. Nothing to do but wait; `ruby_native withdraw` takes it back out."
+                   when "release" then "#{label}: approved and waiting for you. Press Release on the Submit page at rubynative.com."
+                   when "go_live" then "#{label}: everything Google Play needs is in place."
+                   else "#{label}: nothing is in the way of a build. Run `bundle exec ruby_native deploy#{" --android" if android}`."
+                   end ]
+        end
+
+        verb = case act
+               when "submit" then "submitting"
+               when "go_live" then "going live on Google Play"
+               else "building"
+               end
+        [ "#{label}: before #{verb}, #{blockers.size} #{blockers.size == 1 ? "thing needs" : "things need"} doing:", "" ] +
+          blocker_lines(blockers)
+      end
+
+      # A live store due a build: why, the version, and the site's gem first when the release needs it.
+      def self.update_line(update, label, android)
+        command = "`bundle exec ruby_native deploy#{" --android" if android} --version=#{update["version"]}`"
+        gem_step = update["gem_step"].to_s.sub(/\.\z/, "")
+        how = gem_step.empty? ? command : "#{gem_step[0].downcase}#{gem_step[1..]}, then #{command}"
+        "#{label}: #{update["reason"]} Release version #{update["version"]}: #{how}."
+      end
+
+      # The steps are the same copy the dashboard shows, so a person reading
+      # them off a terminal and one reading them off the web are told the
+      # same thing.
+      def self.blocker_lines(blockers)
+        blockers.each_with_index.flat_map do |blocker, index|
+          who = blocker["who"] == "agent" ? "an agent can do this" : "a person does this"
+          seen = blocker["verifiable"] ? "Ruby Native sees it clear" : "Ruby Native cannot see it, so it is marked done on the dashboard"
+
+          lines = [ "#{index + 1}. #{blocker["id"]} (#{who}; #{seen})" ]
+          lines << "   #{blocker["why"]}" if blocker["why"]
+          lines << "   #{blocker["url"]}" if blocker["url"]
+          Array(blocker["steps"]).each_with_index { |step, i| lines << "     #{i + 1}. #{step}" }
+          lines << ""
+          lines
+        end
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/submit.rb

@@ -0,0 +1,91 @@
+require "ruby_native/cli/command"
+
+module RubyNative
+  class CLI
+    # Submitting for App Store review is two calls. The first returns exactly
+    # what would go to Apple and a token that expires in minutes; the second
+    # needs the token. Here the person reads the summary and answers; the MCP
+    # tool shows the model the same summary and tells it to ask.
+    class Submit < Command
+      def run
+        ensure_authenticated!
+        app_id = app_id!
+
+        # A questionnaire Apple or Google gives us no API for closes on the
+        # person's word, and the word can ride along: --confirm=app_privacy.
+        confirmations = @argv.select { |arg| arg.start_with?("--confirm=") }.map { |arg| arg.split("=", 2).last.to_s.strip }.reject(&:empty?)
+        platforms = platforms!(app_id)
+
+        # Play has no submit of ours: the answer is the go-live list with the
+        # promotion steps, and nothing to confirm. It prints first so the
+        # App Store question is the last thing on screen.
+        android = (self.class.preview(app_id, platform: "android", confirmations: confirmations) if platforms.include?("android"))
+        return finish(android) unless platforms.include?("ios")
+
+        if android
+          puts "Android:\n#{android.text}\n\niOS:"
+        end
+        ios = submit_ios(app_id, confirmations)
+        puts ios.text
+        exit 1 unless ios.ok && (android.nil? || android.ok)
+      end
+
+      def submit_ios(app_id, confirmations)
+        preview = self.class.preview(app_id, confirmations: confirmations)
+        return preview unless preview.ok
+
+        puts preview.text
+        puts ""
+
+        unless @argv.include?("--yes")
+          print "Submit for review? Type yes to continue: "
+          answer = $stdin.gets.to_s.strip.downcase
+          return Outcome.new(ok: false, text: "Not submitted.", data: {}) unless answer == "yes"
+        end
+
+        self.class.submit(app_id, preview.data["confirmation_token"])
+      end
+
+      def self.preview(app_id, platform: "ios", confirmations: [])
+        body = {}
+        body[:platform] = "android" if platform == "android"
+        body[:confirm] = confirmations if confirmations.any?
+        result = Mcp::Platform.post("/api/v1/apps/#{app_id}/submission", body.empty? ? nil : body)
+        return failure(result) unless result.ok?
+
+        text = result.value["summary"].to_s
+        blockers = result.value["blocked_by"]
+        if platform == "android" && blockers.is_a?(Array) && blockers.any?
+          text += "\n\n" + Status.blocker_lines(blockers).join("\n")
+        end
+        success(text, result.value)
+      end
+
+      def self.submit(app_id, confirmation_token)
+        return Outcome.new(ok: false, text: "No confirmation token. Preview the submission first.", data: {}) if confirmation_token.to_s.empty?
+
+        result = Mcp::Platform.post("/api/v1/apps/#{app_id}/submission", { confirmation_token: confirmation_token })
+        return failure(result) unless result.ok?
+
+        success(result.value["note"].to_s, result.value)
+      end
+
+      def self.withdraw(app_id, platform: "ios")
+        result = Mcp::Platform.request(Net::HTTP::Delete, "/api/v1/apps/#{app_id}/submission#{"?platform=android" if platform == "android"}")
+        return failure(result) unless result.ok?
+
+        success(result.value["note"].to_s, result.value)
+      end
+    end
+
+    class Withdraw < Command
+      def run
+        ensure_authenticated!
+        app_id = app_id!
+        # Play has no review queue to leave, so only --android asks it.
+        platforms = @argv.include?("--android") ? [ "android" ] : [ "ios" ]
+        finish_each(platforms) { |platform| Submit.withdraw(app_id, platform: platform) }
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/testers.rb

@@ -0,0 +1,54 @@
+require "ruby_native/cli/command"
+
+module RubyNative
+  class CLI
+    # Internal TestFlight testers. Adding one reaches App Store Connect, through
+    # rubynative.com, which holds the key.
+    class Testers < Command
+      def run
+        ensure_authenticated!
+        app_id = app_id!
+
+        case positional.first
+        when "add"
+          email = positional[1]
+          unless email
+            puts "Usage: ruby_native testers add <email> [--ios|--android]"
+            exit 1
+          end
+          finish_each(platforms!(app_id)) { |platform| self.class.add(app_id, email, platform: platform) }
+        when "list", nil
+          finish_each(platforms!(app_id)) { |platform| self.class.list(app_id, platform: platform) }
+        else
+          puts "Unknown testers command #{positional.first.inspect}. Use `add` or `list`."
+          exit 1
+        end
+      end
+
+      # Play keeps its tester list in the Console, so `--android` comes back
+      # as the hand-off in the blockers shape rather than a list.
+      def self.list(app_id, platform: "ios")
+        result = Mcp::Platform.get("/api/v1/apps/#{app_id}/testers#{"?platform=android" if platform == "android"}")
+        return failure(result) unless result.ok?
+
+        testers = Array(result.value["testers"])
+        return success("No testers yet. Add one with `ruby_native testers add <email>`.", result.value) if testers.empty?
+
+        width = testers.map { |tester| tester["email"].to_s.length }.max
+        lines = testers.map do |tester|
+          "#{tester["email"].to_s.ljust(width)}  #{tester["accepted"] ? "accepted" : "invited, not accepted"}"
+        end
+        success(lines.join("\n"), result.value)
+      end
+
+      def self.add(app_id, email, platform: "ios")
+        body = { email: email }
+        body[:platform] = "android" if platform == "android"
+        result = Mcp::Platform.post("/api/v1/apps/#{app_id}/testers", body)
+        return failure(result) unless result.ok?
+
+        success(result.value["message"].to_s, result.value)
+      end
+    end
+  end
+end