fastlane 2.233.1 → 2.235.0

data/deliver/lib/deliver/upload_app_clip_default_experience_header_images.rb

@@ -0,0 +1,188 @@
+require 'fastlane_core'
+require 'spaceship/tunes/tunes'
+require 'digest/md5'
+
+require_relative 'module'
+require_relative 'loader'
+
+module Deliver
+  class UploadAppClipDefaultExperienceHeaderImages
+    UploadAppClipHeaderImageJob = Struct.new(:path, :localization)
+
+    def find_and_upload(options)
+      return if options[:edit_live] || options[:app_clip_header_images_path].nil?
+
+      app_clip_header_images = collect_app_clip_header_images(options)
+
+      app = Deliver.cache[:app]
+
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+      version = app.get_edit_app_store_version(platform: platform, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES + ",appClipDefaultExperience")
+      UI.user_error!("Could not find a version to edit for app '#{app.name}' for '#{platform}'") unless version
+
+      app_clip_default_experience = version.app_clip_default_experience
+      UI.user_error!("Could not find a default app clip experience for version '#{version}'. Use the :app_clip_default_experience_subtitle and :app_clip_default_experience_action options to create and add metadata to the app clip default experience for this version.") unless app_clip_default_experience
+
+      UI.important("Will begin uploading app clip default experience header images for '#{version.version_string}' on App Store Connect")
+      UI.message("Starting with the upload of app clip header images...")
+
+      upload(app_clip_default_experience, app_clip_header_images)
+
+      UI.success("Successfully uploaded app clip default experience header images to App Store Connect")
+    end
+
+    def upload(app_clip_default_experience, app_clip_header_images)
+      # get the existing localizations and their header images
+      app_clip_default_experience_localizations = Spaceship::ConnectAPI::AppClipDefaultExperienceLocalization.find_all(app_clip_default_experience_id: app_clip_default_experience.id, includes: 'appClipHeaderImage')
+
+      # Create missing localizations for languages that have header images but no localization
+      app_clip_header_images.each do |header_image|
+        # Skip if language is nil or empty
+        next if header_image.language.nil? || header_image.language.empty?
+
+        existing_localization = app_clip_default_experience_localizations.find { |l| l.locale.eql?(header_image.language) }
+        next if existing_localization
+
+        UI.message("Creating app clip default experience localization for '#{header_image.language}'")
+        new_localization = Spaceship::ConnectAPI::AppClipDefaultExperienceLocalization.create(
+          default_experience_id: app_clip_default_experience.id,
+          attributes: { locale: header_image.language }
+        )
+        app_clip_default_experience_localizations << new_localization
+      end
+
+      # Upload app clip header images
+      worker = FastlaneCore::QueueWorker.new do |job|
+        begin
+          localization = job.localization
+
+          # if there's an existing header image, it must be deleted before uploading the new one
+          unless localization.app_clip_header_image.nil?
+            localization.app_clip_header_image.delete!
+            UI.verbose("[#{localization.locale}] Removed existing header image")
+          end
+
+          UI.verbose("[#{localization.locale}] Uploading '#{job.path}'...")
+          start_time = Time.now
+          Spaceship::ConnectAPI::AppClipHeaderImage.create(app_clip_default_experience_localization_id: localization.id, path: job.path, wait_for_processing: false)
+          UI.message("Uploaded '#{job.path}'... (#{Time.now - start_time} secs)")
+        rescue => error
+          UI.error(error)
+        end
+      end
+
+      app_clip_header_images.each do |header_image|
+        localization = app_clip_default_experience_localizations.find { |l| l.locale.eql?(header_image.language) }
+        unless localization
+          UI.error("Could not find or create localization for #{header_image.language}")
+          next
+        end
+
+        # check to see if it's already uploaded
+        checksum = UploadAppClipDefaultExperienceHeaderImages.calculate_checksum(header_image.path)
+        if !localization.app_clip_header_image.nil? && checksum.eql?(localization.app_clip_header_image.source_file_checksum)
+          UI.message("Skipping '#{header_image.path}' as it is already uploaded")
+          next
+        end
+
+        # upload
+        worker.enqueue(UploadAppClipHeaderImageJob.new(header_image.path, localization))
+      end
+
+      worker.start
+
+      UI.verbose('Uploading jobs are completed')
+
+      Helper.show_loading_indicator("Waiting for all the app clip header images to finish being processed...")
+      wait_for_complete(app_clip_default_experience.id)
+      Helper.hide_loading_indicator
+
+      UI.message("Successfully uploaded all app clip header images")
+    end
+
+    # Verify all screenshots have been processed
+    # Functionality copied and modified from upload_screenshots.rb
+    def wait_for_complete(app_clip_default_experience_id)
+      loop do
+        # fetch
+        app_clip_default_experience_localizations = Spaceship::ConnectAPI::AppClipDefaultExperienceLocalization.find_all(app_clip_default_experience_id: app_clip_default_experience_id, includes: 'appClipHeaderImage')
+        header_images = app_clip_default_experience_localizations.map(&:app_clip_header_image)
+
+        # group states
+        states = header_images.each_with_object({}) do |header_image, hash|
+          next unless header_image
+
+          state = header_image.asset_delivery_state['state']
+          hash[state] ||= 0
+          hash[state] += 1
+        end
+
+        is_processing = states.fetch('UPLOAD_COMPLETE', 0) > 0
+        return states unless is_processing
+
+        UI.verbose("There are still incomplete app clip header images - #{states}")
+        sleep(5)
+      end
+    end
+
+    def collect_app_clip_header_images(options)
+      app_clip_header_images = Loader.load_app_clip_header_images(options[:app_clip_header_images_path], options[:ignore_language_directory_validation])
+
+      # Apply default folder logic similar to metadata
+      assign_default_images(options, app_clip_header_images)
+
+      return app_clip_header_images
+    end
+
+    # If the user has a 'default' language folder, assign those images to languages that don't have images
+    def assign_default_images(options, app_clip_header_images)
+      # Build a complete list of the required languages
+      enabled_languages = detect_languages(options, app_clip_header_images)
+
+      # Check if there's a default image (from 'default' folder)
+      default_image = app_clip_header_images.find do |img|
+        folder_name = File.basename(File.dirname(img.path))
+        folder_name.casecmp?("default")
+      end
+      return unless default_image
+
+      # For each enabled language, if there's no image, use the default
+      enabled_languages.each do |language|
+        next if language&.casecmp?("default")
+
+        existing_image = app_clip_header_images.find { |img| img.language.eql?(language) }
+        unless existing_image
+          UI.message("Using default folder image for language '#{language}'")
+          app_clip_header_images << Deliver::AppClipHeaderImage.new(default_image.path, language)
+        end
+      end
+
+      # Remove the default image from the list (language is nil for default folder)
+      app_clip_header_images.reject! { |img| img.language.nil? }
+    end
+
+    def detect_languages(options, app_clip_header_images)
+      # Start with languages from the common detection method
+      enabled_languages = Languages.detect_languages(
+        options: options,
+        metadata_path: options[:app_clip_header_images_path],
+        ignore_validation: options[:ignore_language_directory_validation]
+      )
+
+      # Also add languages from existing header images
+      app_clip_header_images.each do |header_image|
+        language = header_image.language
+        next if language.nil? || language.empty?
+        enabled_languages << language unless enabled_languages.include?(language)
+      end
+
+      enabled_languages.uniq
+    end
+
+    # helper method to mock this step in tests
+    def self.calculate_checksum(path)
+      bytes = File.binread(path)
+      Digest::MD5.hexdigest(bytes)
+    end
+  end
+end

data/deliver/lib/deliver/upload_app_clip_default_experience_metadata.rb

@@ -0,0 +1,229 @@
+require 'fastlane_core'
+require 'spaceship'
+
+require_relative 'module'
+
+module Deliver
+  # rubocop:disable Metrics/ClassLength
+  class UploadAppClipDefaultExperienceMetadata
+    LOCALISED_APP_CLIP_DEFAULT_EXPERIENCE_VALUES = {
+      app_clip_default_experience_subtitle: "app_clip_default_experience_subtitle"
+    }
+
+    NON_LOCALISED_APP_CLIP_DEFAULT_EXPERIENCE_VALUES = {
+      app_clip_default_experience_action: "app_clip_default_experience_action"
+    }
+
+    require_relative 'loader'
+
+    def upload_metadata(options)
+      # app clip default experience metadata is not editable in a live version
+      return if options[:edit_live] || options[:app_clip_default_experience_metadata_path].nil?
+
+      # load the metadata from the filesystem before uploading
+      load_from_filesystem(options)
+
+      # Assign default values to all languages
+      assign_defaults(options)
+
+      app = Deliver.cache[:app]
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+      version = fetch_edit_app_store_version(app, platform)
+
+      UI.important("Will begin uploading app clip default experience metadata for '#{version.version_string}' on App Store Connect")
+
+      # Currently only one app clip target per app is supported
+      app_clips = app.get_app_clips
+      app_clip = app_clips.first
+
+      # Validate options
+      subtitle_localized = options[:app_clip_default_experience_subtitle]
+      action = options[:app_clip_default_experience_action]
+      has_options_specified = !subtitle_localized.nil? || !action.nil?
+
+      if app_clip.nil?
+        UI.user_error!("A build with an app clip must be uploaded to App Store Connect before uploading the default experience metadata") if has_options_specified
+        # Nothing to do if the app clip is nil and no app clip options specified
+        return
+      end
+
+      unless has_options_specified
+        # Handle the default case where there is an app clip, but no options specified.
+        return copy_live_version_app_clip_default_experience_metadata(app: app, platform: platform, edit_version: version, app_clip: app_clip)
+      end
+
+      UI.user_error!("You must provide at least the subtitle and action for an app clip default experience") if subtitle_localized.nil? || action.nil?
+
+      # see if there's an existing experience for this version
+      default_experience = version.app_clip_default_experience
+      if default_experience
+        # update the existing default experience
+        default_experience.update(attributes: { action: action })
+        UI.message("Updated app clip default experience")
+      else
+        # create a new default experience
+        default_experience = Spaceship::ConnectAPI::AppClipDefaultExperience.create(app_clip_id: app_clip.id, app_store_version_id: version.id, attributes: { action: action })
+        UI.important("Created default experience for version '#{version.version_string}'")
+      end
+
+      # update the subtitle localizations
+      upload_subtitle_localizations(app_clip_default_experience: default_experience, subtitle_localizations: subtitle_localized)
+    end
+
+    # Loads the app clip default experience metadata files and stores them into the options object
+    def load_from_filesystem(options)
+      metadata_path = options[:app_clip_default_experience_metadata_path]
+
+      # Load localised data
+      ignore_validation = options[:ignore_language_directory_validation]
+      Loader.language_folders(metadata_path, ignore_validation).each do |lang_folder|
+        LOCALISED_APP_CLIP_DEFAULT_EXPERIENCE_VALUES.keys.each do |key|
+          path = File.join(lang_folder.path, "#{key}.txt")
+          next unless File.exist?(path)
+
+          UI.message("Loading '#{path}'...")
+          options[key] ||= {}
+          options[key][lang_folder.basename] ||= File.read(path).strip
+        end
+      end
+
+      # Load non localised data
+      NON_LOCALISED_APP_CLIP_DEFAULT_EXPERIENCE_VALUES.keys.each do |key|
+        path = File.join(metadata_path, "#{key}.txt")
+        next unless File.exist?(path)
+
+        UI.message("Loading '#{path}'...")
+        options[key] ||= File.read(path).strip
+      end
+    end
+
+    # If the user is using the 'default' language, then assign values where they are needed
+    def assign_defaults(options)
+      # Build a complete list of the required languages
+      enabled_languages = detect_languages(options)
+
+      return unless enabled_languages.include?("default")
+      UI.message("Detected languages for app clip default experience: " + enabled_languages.to_s)
+
+      LOCALISED_APP_CLIP_DEFAULT_EXPERIENCE_VALUES.keys.each do |key|
+        current = options[key]
+        next unless current && current.kind_of?(Hash)
+
+        default = current["default"]
+        next if default.nil?
+
+        enabled_languages.each do |language|
+          value = current[language]
+          next unless value.nil?
+
+          current[language] = default
+        end
+        current.delete("default")
+      end
+    end
+
+    def detect_languages(options)
+      Languages.detect_languages(
+        options: options,
+        localized_values_keys: LOCALISED_APP_CLIP_DEFAULT_EXPERIENCE_VALUES.keys,
+        metadata_path: options[:app_clip_default_experience_metadata_path],
+        ignore_validation: options[:ignore_language_directory_validation]
+      )
+    end
+
+    # from upload_metadata.rb
+    def fetch_edit_app_store_version(app, platform, wait_time: 10)
+      retry_if_nil("Cannot find edit app store version", wait_time: wait_time) do
+        app.get_edit_app_store_version(platform: platform, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES + ",appClipDefaultExperience")
+      end
+    end
+
+    def fetch_live_app_store_version(app, platform, wait_time: 10)
+      retry_if_nil("Cannot find live app store version", wait_time: wait_time) do
+        app.get_live_app_store_version(platform: platform, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES + ",appClipDefaultExperience")
+      end
+    end
+
+    # from upload_metadata.rb
+    def retry_if_nil(message, tries: 5, wait_time: 10)
+      loop do
+        tries -= 1
+
+        value = yield
+        return value if value
+
+        UI.message("#{message}... Retrying after #{wait_time} seconds (remaining: #{tries})")
+        sleep(wait_time)
+
+        return nil if tries.zero?
+      end
+    end
+
+    def upload_subtitle_localizations(app_clip_default_experience:, subtitle_localizations:)
+      localized_subtitle_attributes_by_locale = {}
+      subtitle_localizations.keys.each do |key|
+        localized_subtitle_attributes_by_locale[key] = {}
+        localized_subtitle_attributes_by_locale[key][:create_attributes] = { subtitle: subtitle_localizations[key], locale: key }
+        localized_subtitle_attributes_by_locale[key][:update_attributes] = { subtitle: subtitle_localizations[key] }
+      end
+
+      # update the subtitle
+      existing_localizations = Spaceship::ConnectAPI::AppClipDefaultExperienceLocalization.find_all(app_clip_default_experience_id: app_clip_default_experience.id)
+
+      # from upload_metadata.rb
+      app_info_worker = FastlaneCore::QueueWorker.new do |locale|
+        UI.message("Uploading app clip default experience metadata to App Store Connect for localized subtitle '#{locale}'")
+
+        # find an existing localization
+        existing_localization = existing_localizations.find { |l| locale.to_s.eql?(l.locale) }
+
+        if existing_localization
+          # update existing
+          attributes = localized_subtitle_attributes_by_locale[locale][:update_attributes]
+          existing_localization.update(attributes: attributes)
+          UI.verbose("[#{locale}] Updated existing to #{attributes}")
+        else
+          # create new
+          attributes = localized_subtitle_attributes_by_locale[locale][:create_attributes]
+          Spaceship::ConnectAPI::AppClipDefaultExperienceLocalization.create(default_experience_id: app_clip_default_experience.id, attributes: attributes)
+          UI.verbose("[#{locale}] Created new with #{attributes}")
+        end
+      end
+      app_info_worker.batch_enqueue(localized_subtitle_attributes_by_locale.keys)
+      app_info_worker.start
+    end
+
+    # Handle the case where an app clip exists, but the user did not specify any app clip default
+    # experience metadata options. We check if the current editable version already has the app clip
+    # default experience metadata. If not, copy over the live version's app clip default
+    # experience metadata. This mimics the default behavior of creating an App Store version from
+    # the ASC UI.
+    #
+    # This function will also produce warnings, but not outright fail, when it finds missing app
+    # clip metadata.
+    #
+    # As of 2022-05-18, App Store versions created by the ASC API do not "carry over" the live
+    # version's app clip default experience metadata, so we handle this for the user by default.
+    #
+    def copy_live_version_app_clip_default_experience_metadata(app:, platform:, edit_version:, app_clip:)
+      edit_version_default_experience = edit_version.app_clip_default_experience
+      if !edit_version_default_experience
+        live_version = fetch_live_app_store_version(app, platform)
+        # no live version to carry over metadata from
+        return if live_version.nil?
+
+        live_version_default_experience = live_version.app_clip_default_experience
+        # no live version default experience to carry over metadata from
+        return if live_version_default_experience.nil?
+
+        # create a default experience and use the live version default experience as a "template"
+        Spaceship::ConnectAPI::AppClipDefaultExperience.create(app_clip_id: app_clip.id, app_store_version_id: edit_version.id, template_default_experience_id: live_version_default_experience.id)
+
+        UI.message("Created the app clip default experience using the live version's app clip metadata as a template.")
+      else
+        # if the edit version app clip default experience already exists, just check it's values
+        UI.important("ASC requires the app clip default experience to contain a valid `action` value. To specify this value in fastlane use deliver's `app_clip_default_experience_action` option.") if edit_version_default_experience.action.nil?
+      end
+    end
+  end
+end

data/deliver/lib/deliver/upload_metadata.rb

@@ -59,6 +59,9 @@ module Deliver
       demo_password: "demo_account_password",
       notes: "notes"
     }
+    APP_CLIP_REVIEW_INFORMATION_VALUES = {
+      invocation_urls: "invocation_urls"
+    }
 
     # Localized app details values, that are editable in live state
     LOCALISED_LIVE_VALUES = [:description, :release_notes, :support_url, :marketing_url, :promotional_text, :privacy_url]
@@ -72,7 +75,10 @@ module Deliver
     # Directory name it contains review information
     REVIEW_INFORMATION_DIR = "review_information"
 
-    ALL_META_SUB_DIRS = [TRADE_REPRESENTATIVE_CONTACT_INFORMATION_DIR, REVIEW_INFORMATION_DIR]
+    # Directory name it contains app clip review information
+    APP_CLIP_REVIEW_INFORMATION_DIR = "app_clip_review_information"
+
+    ALL_META_SUB_DIRS = [TRADE_REPRESENTATIVE_CONTACT_INFORMATION_DIR, REVIEW_INFORMATION_DIR, APP_CLIP_REVIEW_INFORMATION_DIR]
 
     # rubocop:disable Metrics/PerceivedComplexity
 
@@ -100,7 +106,7 @@ module Deliver
 
       if options[:edit_live]
         # not all values are editable when using live_version
-        version = app.get_live_app_store_version(platform: platform)
+        version = app.get_live_app_store_version(platform: platform, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES + ",appClipDefaultExperience")
         localised_options = LOCALISED_LIVE_VALUES
         non_localised_options = NON_LOCALISED_LIVE_VALUES
 
@@ -349,6 +355,7 @@ module Deliver
       end
 
       review_information(version)
+      app_clip_review_information(version)
       review_attachment_file(version)
       app_rating(app_info)
     end
@@ -433,9 +440,9 @@ module Deliver
         .uniq
     end
 
-    def fetch_edit_app_store_version(app, platform)
-      retry_if_nil("Cannot find edit app store version") do
-        app.get_edit_app_store_version(platform: platform)
+    def fetch_edit_app_store_version(app, platform, wait_time: 10)
+      retry_if_nil("Cannot find edit app store version", wait_time: wait_time) do
+        app.get_edit_app_store_version(platform: platform, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES + ",appClipDefaultExperience")
       end
     end
 
@@ -452,9 +459,8 @@ module Deliver
     end
 
     # Retries a block of code if the return value is nil, with an exponential backoff.
-    def retry_if_nil(message)
+    def retry_if_nil(message, wait_time: 10)
       tries = options[:version_check_wait_retry_limit]
-      wait_time = 10
       loop do
         tries -= 1
 
@@ -633,6 +639,22 @@ module Deliver
         next if path.nil?
         options[:app_review_information][option_name] ||= File.read(path)
       end
+
+      # Load app clip review information
+      options[:app_clip_review_information] ||= {}
+      resolve_app_clip_review_info_path = lambda do |option_name|
+        path = File.join(options[:metadata_path], APP_CLIP_REVIEW_INFORMATION_DIR, "#{option_name}.txt")
+        return nil unless File.exist?(path)
+        return nil if options[:app_clip_review_information][option_name].to_s.length > 0
+        return path
+      end
+
+      # Then app clip load review information from new App Store Connect filenames
+      APP_CLIP_REVIEW_INFORMATION_VALUES.keys.each do |option_name|
+        path = resolve_app_clip_review_info_path.call(option_name)
+        next if path.nil?
+        options[:app_clip_review_information][option_name] ||= File.read(path)
+      end
     end
 
     private
@@ -684,6 +706,48 @@ module Deliver
       end
     end
 
+    def app_clip_review_information(version)
+      info = options[:app_clip_review_information]
+      return if info.nil? || info.empty?
+
+      UI.user_error!("`app_clip_review_information` must be a hash", show_github_issues: true) unless info.kind_of?(Hash)
+      info = info.transform_keys(&:to_sym)
+      attributes = {}
+      APP_CLIP_REVIEW_INFORMATION_VALUES.each do |key, attribute_name|
+        if info[key].kind_of?(Array)
+          attributes[attribute_name] = info[key].map { |value| value.to_s.strip } unless info[key].empty?
+        else
+          strip_value = info[key].to_s.strip
+          attributes[attribute_name] = strip_value unless strip_value.empty?
+        end
+      end
+
+      if attributes["invocation_urls"].kind_of?(String)
+        attributes["invocation_urls"] = attributes["invocation_urls"].split(", ")
+      end
+
+      UI.message("Uploading app clip review information to App Store Connect")
+      default_experience = version.app_clip_default_experience
+      if default_experience.nil?
+        # By this point the upload app clip default experience metadata step should have run and
+        # created a default experience, if not, we shouldn't create the default experience here.
+        UI.important("Could not upload app clip review information due to the app clip default experience missing.")
+        return
+      end
+
+      app_clip_app_store_review_detail = begin
+                                  Spaceship::ConnectAPI::AppClipDefaultExperience.get(app_clip_default_experience_id: default_experience.id, includes: "appClipAppStoreReviewDetail").app_clip_app_store_review_detail
+                                rescue => error
+                                  UI.error("Error fetching app clip app store review detail - #{error.message}")
+                                  nil
+                                end # errors if doesn't exist
+      if app_clip_app_store_review_detail
+        app_clip_app_store_review_detail.update(attributes: attributes)
+      else
+        Spaceship::ConnectAPI::AppClipAppStoreReviewDetail.create(app_clip_default_experience_id: default_experience.id, attributes: attributes)
+      end
+    end
+
     def review_attachment_file(version)
       app_store_review_detail = version.fetch_app_store_review_detail
       app_store_review_attachments = app_store_review_detail.app_store_review_attachments || []

data/deliver/lib/deliver/upload_price_tier.rb

@@ -13,8 +13,10 @@ module Deliver
 
       attributes = {}
 
-      # Check App update method to understand how to use territory_ids.
-      territory_ids = nil # nil won't update app's territory_ids, empty array would remove app from sale.
+      # nil leaves existing territory availability unchanged.
+      # [] intentionally removes the app from sale in all territories.
+      # Pass explicit territory IDs to make the app available only in those territories.
+      territory_ids = nil
 
       # As of 2020-09-14:
       # Official App Store Connect does not have an endpoint to get app prices for an app

data/deliver/lib/deliver/upload_screenshots.rb

@@ -201,7 +201,7 @@ module Deliver
         iterator.each_app_screenshot.select { |_, _, app_screenshot| app_screenshot.error? }.each do |localization, _, app_screenshot|
           UI.error("#{app_screenshot.file_name} for #{localization.locale} has error(s) - #{app_screenshot.error_messages.join(', ')}")
         end
-        incomplete_screenshot_count = states.reject { |k, v| k == 'COMPLETE' }.reduce(0) { |sum, (k, v)| sum + v }
+        incomplete_screenshot_count = states.except('COMPLETE').reduce(0) { |sum, (k, v)| sum + v }
         UI.user_error!("Failed verification of all screenshots uploaded... #{incomplete_screenshot_count} incomplete screenshot(s) still exist")
       else
         UI.error("Failed to upload all screenshots... Tries remaining: #{tries}")

data/fastlane/lib/fastlane/actions/app_store_connect_api_key.rb

@@ -9,8 +9,8 @@ module Fastlane
 
     class AppStoreConnectApiKeyAction < Action
       def self.run(options)
-        key_id = options[:key_id]
-        issuer_id = options[:issuer_id]
+        key_id = options[:key_id]&.strip
+        issuer_id = options[:issuer_id]&.strip
         key_content = options[:key_content]
         is_key_content_base64 = options[:is_key_content_base64]
         key_filepath = options[:key_filepath]

data/fastlane/lib/fastlane/actions/appium.rb

@@ -41,7 +41,7 @@ module Fastlane
       end
 
       def self.detect_appium(params)
-        appium_path = params[:appium_path] || `which appium`.to_s.strip
+        appium_path = params[:appium_path] || Helper.which('appium').to_s
 
         if appium_path.empty?
           if File.exist?(APPIUM_PATH_HOMEBREW)

data/fastlane/lib/fastlane/actions/appledoc.rb

@@ -56,7 +56,7 @@ module Fastlane
       def self.run(params)
         unless Helper.test?
           UI.message("Install using `brew install appledoc`")
-          UI.user_error!("appledoc not installed") if `which appledoc`.length == 0
+          UI.user_error!("appledoc not installed") unless Helper.which('appledoc')
         end
 
         params_hash = params.values

data/fastlane/lib/fastlane/actions/create_app_on_managed_play_store.rb

@@ -57,7 +57,7 @@ module Fastlane
                                        short_option: "-j",
                                        conflicting_options: [:json_key_data],
                                        optional: true, # optional until it is possible specify either json_key OR json_key_data are required
-                                       description: "The path to a file containing service account JSON, used to authenticate with Google",
+                                       description: "The path to a Google credentials JSON file (Application Default, Workload Identity, or Service Account), used to authenticate with Google",
                                        code_gen_sensitive: true,
                                        default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_file),
                                        default_value_dynamic: true,
@@ -70,7 +70,7 @@ module Fastlane
                                        short_option: "-c",
                                        conflicting_options: [:json_key],
                                        optional: true,
-                                       description: "The raw service account JSON data used to authenticate with Google",
+                                       description: "The raw content of a Google credentials JSON file (Application Default, Workload Identity, or Service Account) used to authenticate with Google",
                                        code_gen_sensitive: true,
                                        default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_data_raw),
                                        default_value_dynamic: true,