fastlane 2.157.4 → 2.162.0

data/match/lib/match/storage/s3_storage.rb

@@ -19,6 +19,8 @@ module Match
       attr_reader :username
       attr_reader :team_id
       attr_reader :team_name
+      attr_reader :api_key_path
+      attr_reader :api_key
 
       def self.configure(params)
         s3_region = params[:s3_region]
@@ -43,7 +45,9 @@ module Match
           readonly: params[:readonly],
           username: params[:username],
           team_id: params[:team_id],
-          team_name: params[:team_name]
+          team_name: params[:team_name],
+          api_key_path: params[:api_key_path],
+          api_key: params[:api_key]
         )
       end
 
@@ -55,7 +59,9 @@ module Match
                      readonly: nil,
                      username: nil,
                      team_id: nil,
-                     team_name: nil)
+                     team_name: nil,
+                     api_key_path: nil,
+                     api_key: nil)
         @s3_bucket = s3_bucket
         @s3_region = s3_region
         @s3_client = Fastlane::Helper::S3ClientHelper.new(access_key: s3_access_key, secret_access_key: s3_secret_access_key, region: s3_region)
@@ -64,6 +70,8 @@ module Match
         @username = username
         @team_id = team_id
         @team_name = team_name
+        @api_key_path = api_key_path
+        @api_key = api_key
       end
 
       # To make debugging easier, we have a custom exception here
@@ -180,10 +188,18 @@ module Match
           # see `prefixed_working_directory` comments for more details
           return self.team_id
         else
-          spaceship = SpaceshipEnsure.new(self.username, self.team_id, self.team_name)
+          UI.user_error!("The `team_id` option is required. fastlane cannot automatically determine portal team id via the App Store Connect API (yet)") if self.team_id.to_s.empty?
+
+          spaceship = SpaceshipEnsure.new(self.username, self.team_id, self.team_name, api_token)
           return spaceship.team_id
         end
       end
+
+      def api_token
+        api_token ||= Spaceship::ConnectAPI::Token.create(self.api_key) if self.api_key
+        api_token ||= Spaceship::ConnectAPI::Token.from_json_file(self.api_key_path) if self.api_key_path
+        return api_token
+      end
     end
   end
 end

data/pilot/lib/pilot/options.rb

@@ -12,7 +12,7 @@ module Pilot
       [
         FastlaneCore::ConfigItem.new(key: :api_key_path,
                                      env_name: "PILOT_API_KEY_PATH",
-                                     description: "Path to your App Store Connect API key JSON file",
+                                     description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
                                      optional: true,
                                      conflicting_options: [:username],
                                      verify_block: proc do |value|
@@ -20,7 +20,7 @@ module Pilot
                                      end),
         FastlaneCore::ConfigItem.new(key: :api_key,
                                      env_name: "PILOT_API_KEY",
-                                     description: "Path to your App Store Connect API key JSON file",
+                                     description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#use-return-value-and-pass-in-as-an-option)",
                                      type: Hash,
                                      optional: true,
                                      sensitive: true,

data/precheck/lib/precheck/options.rb

@@ -25,6 +25,22 @@ module Precheck
       user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
 
       [
+        FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                     env_name: "PRECHECK_API_KEY_PATH",
+                                     description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
+                                     optional: true,
+                                     conflicting_options: [:username],
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :api_key,
+                                     env_name: "PRECHECK_API_KEY",
+                                     description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#use-return-value-and-pass-in-as-an-option)",
+                                     type: Hash,
+                                     optional: true,
+                                     sensitive: true,
+                                     conflicting_options: [:api_key_path, :username]),
+
         FastlaneCore::ConfigItem.new(key: :app_identifier,
                                      short_option: "-a",
                                      env_name: "PRECHECK_APP_IDENTIFIER",
@@ -60,6 +76,15 @@ module Precheck
                                      verify_block: proc do |value|
                                        ENV["FASTLANE_ITC_TEAM_NAME"] = value.to_s
                                      end),
+        FastlaneCore::ConfigItem.new(key: :platform,
+                                     short_option: "-j",
+                                     env_name: "PRECHECK_PLATFORM",
+                                     description: "The platform to use (optional)",
+                                     optional: true,
+                                     default_value: "ios",
+                                     verify_block: proc do |value|
+                                       UI.user_error!("The platform can only be ios, appletvos, or osx") unless %('ios', 'appletvos', 'osx').include?(value)
+                                     end),
         FastlaneCore::ConfigItem.new(key: :default_rule_level,
                                      short_option: "-r",
                                      env_name: "PRECHECK_DEFAULT_RULE_LEVEL",

data/precheck/lib/precheck/rule_processor.rb

@@ -1,4 +1,5 @@
 require 'spaceship/tunes/language_item'
+require 'spaceship/tunes/iap_list'
 require 'fastlane/markdown_table_formatter'
 
 require_relative 'module'
@@ -43,8 +44,8 @@ module Precheck
   class RuleProcessor
     def self.process_app_and_version(app: nil, app_version: nil, rules: nil)
       items_to_check = []
-      items_to_check += generate_text_items_to_check(app: app, app_version: app_version)
-      items_to_check += generate_url_items_to_check(app: app, app_version: app_version)
+      items_to_check += generate_app_items_to_check(app: app)
+      items_to_check += generate_version_items_to_check(app_version: app_version)
 
       return process_rules(items_to_check: items_to_check, rules: rules)
     end
@@ -125,66 +126,41 @@ module Precheck
       return rule_hash
     end
 
-    def self.generate_url_items_to_check(app: nil, app_version: nil)
+    def self.generate_app_items_to_check(app: nil)
       items = []
-      items += collect_urls_from_hash(hash: app_version.support_url,
-                                 item_name: :support_url,
-                     friendly_name_postfix: "support URL")
-      items += collect_urls_from_hash(hash: app_version.marketing_url,
-                                 item_name: :marketing_url,
-                     friendly_name_postfix: "marketing URL",
-                               is_optional: true)
-
-      items += collect_urls_from_hash(hash: app.details.privacy_url,
-                                 item_name: :privacy_url,
-                     friendly_name_postfix: "privacy URL",
-                               is_optional: true)
-      return items
-    end
 
-    def self.collect_urls_from_hash(hash: nil, item_name: nil, friendly_name_postfix: nil, is_optional: false)
-      items = []
-      hash.each do |key, value|
-        items << URLItemToCheck.new(value, item_name, "#{friendly_name_postfix}: (#{key})", is_optional)
+      # App info localizations
+      app_info = app.fetch_edit_app_info
+      app_info_localizations = app_info.get_app_info_localizations
+      app_info_localizations.each do |localization|
+        items << collect_text_items_from_language_item(locale: localization.locale,
+                                                        value: localization.name,
+                                                    item_name: :app_name,
+                                        friendly_name_postfix: "app name")
+
+        items << collect_text_items_from_language_item(locale: localization.locale,
+                                                        value: localization.subtitle,
+                                                    item_name: :app_subtitle,
+                                        friendly_name_postfix: "app name subtitle",
+                                                  is_optional: true)
+
+        items << collect_text_items_from_language_item(locale: localization.locale,
+                                                        value: localization.privacy_policy_text,
+                                                    item_name: :privacy_policy_text,
+                                        friendly_name_postfix: " tv privacy policy")
+
+        items << collect_urls_from_language_item(locale: localization.locale,
+                                                        value: localization.privacy_policy_url,
+                                                    item_name: :privacy_policy_url,
+                                        friendly_name_postfix: "privacy URL",
+                                                  is_optional: true)
       end
-      return items
-    end
-
-    def self.generate_text_items_to_check(app: nil, app_version: nil)
-      items = []
-
-      items << TextItemToCheck.new(app_version.copyright, :copyright, "copyright")
-
-      items += collect_text_items_from_language_item(hash: app_version.keywords,
-                                                item_name: :keywords,
-                                    friendly_name_postfix: "keywords")
-
-      items += collect_text_items_from_language_item(hash: app_version.description,
-                                                item_name: :description,
-                                    friendly_name_postfix: "description")
-
-      items += collect_text_items_from_language_item(hash: app_version.release_notes,
-                                                item_name: :release_notes,
-                                    friendly_name_postfix: "release notes")
-
-      items += collect_text_items_from_language_item(hash: app.details.name,
-                                                item_name: :app_name,
-                                    friendly_name_postfix: "app name")
-
-      items += collect_text_items_from_language_item(hash: app.details.apple_tv_privacy_policy,
-                                                item_name: :app_subtitle,
-                                    friendly_name_postfix: " tv privacy policy")
-
-      items += collect_text_items_from_language_item(hash: app.details.subtitle,
-                                                item_name: :app_subtitle,
-                                    friendly_name_postfix: "app name subtitle",
-                                              is_optional: true)
 
       should_include_iap = Precheck.config[:include_in_app_purchases]
       if should_include_iap
         UI.message("Reading in-app purchases. If you have a lot, this might take a while")
         UI.message("You can disable IAP checking by setting the `include_in_app_purchases` flag to `false`")
-        in_app_purchases = app.in_app_purchases.all
+        in_app_purchases = get_iaps(app_id: app.id)
         in_app_purchases ||= []
         in_app_purchases.each do |purchase|
           items += collect_iap_language_items(purchase_edit_versions: purchase.edit.versions)
@@ -195,6 +171,64 @@ module Precheck
       return items
     end
 
+    def self.generate_version_items_to_check(app_version: nil)
+      items = []
+
+      items << TextItemToCheck.new(app_version.copyright, :copyright, "copyright")
+
+      # Version localizations
+      version_localizations = app_version.get_app_store_version_localizations
+      version_localizations.each do |localization|
+        items << collect_text_items_from_language_item(locale: localization.locale,
+                                                        value: localization.keywords,
+                                                    item_name: :keywords,
+                                        friendly_name_postfix: "keywords")
+
+        items << collect_text_items_from_language_item(locale: localization.locale,
+                                                        value: localization.description,
+                                                    item_name: :description,
+                                        friendly_name_postfix: "description")
+
+        items << collect_text_items_from_language_item(locale: localization.locale,
+                                                        value: localization.whats_new,
+                                                    item_name: :release_notes,
+                                        friendly_name_postfix: "what's new")
+
+        items << collect_urls_from_language_item(locale: localization.locale,
+                                                        value: localization.support_url,
+                                                    item_name: :support_url,
+                                        friendly_name_postfix: "support URL")
+
+        items << collect_urls_from_language_item(locale: localization.locale,
+                                                        value: localization.marketing_url,
+                                                    item_name: :marketing_url,
+                                        friendly_name_postfix: "marketing URL",
+                                                 is_optional: true)
+      end
+
+      return items
+    end
+
+    # As of 2020-09-04, this is the only non App Store Connect call in prechecks
+    # This will need to get replaced when the API becomes available
+    def self.get_iaps(app_id: nil, include_deleted: false)
+      r = Spaceship::Tunes.client.iaps(app_id: app_id)
+      return_iaps = []
+      r.each do |product|
+        attrs = product
+
+        # This is not great but Spaceship::Tunes::IAPList.factory looks
+        # for `application.apple_id`
+        mock_application = OpenStruct.new({ apple_id: app_id })
+        attrs[:application] = mock_application
+
+        loaded_iap = Spaceship::Tunes::IAPList.factory(attrs)
+        next if loaded_iap.status == "deleted" && !include_deleted
+        return_iaps << loaded_iap
+      end
+      return return_iaps
+    end
+
     def self.collect_iap_language_items(purchase_edit_versions: nil, is_optional: false)
       items = []
       purchase_edit_versions.each do |language_key, hash|
@@ -207,12 +241,12 @@ module Precheck
     end
 
     # a few attributes are LanguageItem this method creates a TextItemToCheck for each pair
-    def self.collect_text_items_from_language_item(hash: nil, item_name: nil, friendly_name_postfix: nil, is_optional: false)
-      items = []
-      hash.each do |key, value|
-        items << TextItemToCheck.new(value, item_name, "#{friendly_name_postfix}: (#{key})", is_optional)
-      end
-      return items
+    def self.collect_text_items_from_language_item(locale: nil, value: nil, item_name: nil, friendly_name_postfix: nil, is_optional: false)
+      return TextItemToCheck.new(value, item_name, "#{friendly_name_postfix}: (#{locale})", is_optional)
+    end
+
+    def self.collect_urls_from_language_item(locale: nil, value: nil, item_name: nil, friendly_name_postfix: nil, is_optional: false)
+      return URLItemToCheck.new(value, item_name, "#{friendly_name_postfix}: (#{locale})", is_optional)
     end
   end
 end

data/precheck/lib/precheck/runner.rb

@@ -18,10 +18,24 @@ module Precheck
                                          hide_keys: [:output_path],
                                              title: "Summary for precheck #{Fastlane::VERSION}")
 
-      unless Spaceship::Tunes.client
+      if api_token
+
+        # As of 2020-09-15, App Store Connect API does not have support for IAPs yet
+        # This means that API Key will fail if checking for IAPs.
+        #
+        # There is also a check in Deliver::Runner for this.
+        # Please remove check in Deliver when the API support IAPs.
+        if Precheck.config[:include_in_app_purchases]
+          UI.user_error!("Precheck cannot check In-app purchases with the App Store Connect API Key (yet). Exclude In-app purchases from precheck or use Apple ID login")
+        end
+
+        UI.message("Creating authorization token for App Store Connect API")
+        Spaceship::ConnectAPI.token = api_token
+      elsif Spaceship::Tunes.client.nil?
+        # Team selection passed though FASTLANE_ITC_TEAM_ID and FASTLANE_ITC_TEAM_NAME environment variables
+        # Prompts select team if multiple teams and none specified
         UI.message("Starting login with user '#{Precheck.config[:username]}'")
-        Spaceship::Tunes.login(Precheck.config[:username])
-        Spaceship::Tunes.select_team
+        Spaceship::ConnectAPI.login(Precheck.config[:username], use_portal: false, use_tunes: true)
 
         UI.message("Successfully logged in")
       end
@@ -57,6 +71,12 @@ module Precheck
       return true
     end
 
+    def api_token
+      @api_token ||= Spaceship::ConnectAPI::Token.create(Precheck.config[:api_key]) if Precheck.config[:api_key]
+      @api_token ||= Spaceship::ConnectAPI::Token.from_json_file(Precheck.config[:api_key_path]) if Precheck.config[:api_key_path]
+      return @api_token
+    end
+
     def print_items_not_checked(processor_result: nil)
       names = processor_result.items_not_checked.map(&:friendly_name)
       UI.message("😶  Metadata fields not checked by any rule: #{names.join(', ')}".yellow) if names.length > 0
@@ -160,11 +180,12 @@ module Precheck
     end
 
     def app
-      Spaceship::Tunes::Application.find(Precheck.config[:app_identifier])
+      Spaceship::ConnectAPI::App.find(Precheck.config[:app_identifier])
     end
 
     def latest_app_version
-      @latest_version ||= app.latest_version
+      platform = Spaceship::ConnectAPI::Platform.map(Precheck.config[:platform])
+      @latest_version ||= app.get_edit_app_store_version(platform: platform)
     end
 
     # Makes sure the current App ID exists. If not, it will show an appropriate error message

data/sigh/lib/sigh/options.rb

@@ -54,6 +54,25 @@ module Sigh
                                      code_gen_sensitive: true,
                                      default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier),
                                      default_value_dynamic: true),
+
+        # App Store Connect API
+        FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                     env_name: "SIGH_API_KEY_PATH",
+                                     description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
+                                     optional: true,
+                                     conflicting_options: [:api_key],
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :api_key,
+                                     env_name: "SIGH_API_KEY",
+                                     description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#use-return-value-and-pass-in-as-an-option)",
+                                     type: Hash,
+                                     optional: true,
+                                     sensitive: true,
+                                     conflicting_options: [:api_key_path]),
+
+        # Apple ID
         FastlaneCore::ConfigItem.new(key: :username,
                                      short_option: "-u",
                                      env_name: "SIGH_USERNAME",
@@ -82,6 +101,8 @@ module Sigh
                                      verify_block: proc do |value|
                                        ENV["FASTLANE_TEAM_NAME"] = value.to_s
                                      end),
+
+        # Other options
         FastlaneCore::ConfigItem.new(key: :provisioning_name,
                                      short_option: "-n",
                                      env_name: "SIGH_PROVISIONING_PROFILE_NAME",

data/sigh/lib/sigh/runner.rb

@@ -17,11 +17,16 @@ module Sigh
                                          hide_keys: [:output_path],
                                              title: "Summary for sigh #{Fastlane::VERSION}")
 
-      # Team selection passed though FASTLANE_ITC_TEAM_ID and FASTLANE_ITC_TEAM_NAME environment variables
-      # Prompts select team if multiple teams and none specified
-      UI.message("Starting login with user '#{Sigh.config[:username]}'")
-      Spaceship::ConnectAPI.login(Sigh.config[:username], nil, use_portal: true, use_tunes: false)
-      UI.message("Successfully logged in")
+      if api_token
+        UI.message("Creating authorization token for App Store Connect API")
+        Spaceship::ConnectAPI.token = api_token
+      else
+        # Team selection passed though FASTLANE_ITC_TEAM_ID and FASTLANE_ITC_TEAM_NAME environment variables
+        # Prompts select team if multiple teams and none specified
+        UI.message("Starting login with user '#{Sigh.config[:username]}'")
+        Spaceship::ConnectAPI.login(Sigh.config[:username], nil, use_portal: true, use_tunes: false)
+        UI.message("Successfully logged in")
+      end
 
       profiles = [] if Sigh.config[:skip_fetch_profiles]
       profiles ||= fetch_profiles # download the profile if it's there
@@ -54,6 +59,12 @@ module Sigh
       return download_profile(profile)
     end
 
+    def api_token
+      @api_token ||= Spaceship::ConnectAPI::Token.create(Sigh.config[:api_key]) if Sigh.config[:api_key]
+      @api_token ||= Spaceship::ConnectAPI::Token.from_json_file(Sigh.config[:api_key_path]) if Sigh.config[:api_key_path]
+      return @api_token
+    end
+
     # The kind of provisioning profile we're interested in
     def profile_type
       return @profile_type if @profile_type
@@ -190,65 +201,95 @@ module Sigh
       profiles
     end
 
+    def fetch_certificates(certificate_types)
+      filter = {
+        certificateType: certificate_types.join(',')
+      }
+      return Spaceship::ConnectAPI::Certificate.all(filter: filter)
+    end
+
     def certificates_for_profile_and_platform
+      types = []
+
       case Sigh.config[:platform].to_s
       when 'ios', 'tvos'
         if profile_type == Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_DEVELOPMENT || profile_type == Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_DEVELOPMENT
-          certificates = Spaceship.certificate.development.all +
-                         Spaceship.certificate.apple_development.all
+          types = [
+            Spaceship::ConnectAPI::Certificate::CertificateType::DEVELOPMENT,
+            Spaceship::ConnectAPI::Certificate::CertificateType::IOS_DEVELOPMENT
+          ]
         elsif profile_type == Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_INHOUSE || profile_type == Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_INHOUSE
           # Enterprise accounts don't have access to Apple Distribution certificates
-          certificates = Spaceship.certificate.in_house.all
+          types = [
+            Spaceship::ConnectAPI::Certificate::CertificateType::IOS_DISTRIBUTION
+          ]
         # handles case where the desired certificate type is adhoc but the account is an enterprise account
         # the apple dev portal api has a weird quirk in it where if you query for distribution certificates
         # for enterprise accounts, you get nothing back even if they exist.
-        elsif (profile_type == Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_ADHOC || profile_type == Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_ADHOC) && Spaceship.client && Spaceship.client.in_house?
+        elsif (profile_type == Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_ADHOC || profile_type == Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_ADHOC) && Spaceship::ConnectAPI.client && Spaceship::ConnectAPI.client.in_house?
           # Enterprise accounts don't have access to Apple Distribution certificates
-          certificates = Spaceship.certificate.in_house.all
+          types = [
+            Spaceship::ConnectAPI::Certificate::CertificateType::IOS_DISTRIBUTION
+          ]
         else
-          # Ad hoc or App Store
-          certificates = Spaceship.certificate.production.all +
-                         Spaceship.certificate.apple_distribution.all
+          types = [
+            Spaceship::ConnectAPI::Certificate::CertificateType::DISTRIBUTION,
+            Spaceship::ConnectAPI::Certificate::CertificateType::IOS_DISTRIBUTION
+          ]
         end
 
       when 'macos', 'catalyst'
         if profile_type == Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_DEVELOPMENT || profile_type == Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_DEVELOPMENT
-          certificates = Spaceship.certificate.mac_development.all +
-                         Spaceship.certificate.apple_development.all
+          types = [
+            Spaceship::ConnectAPI::Certificate::CertificateType::DEVELOPMENT,
+            Spaceship::ConnectAPI::Certificate::CertificateType::MAC_APP_DEVELOPMENT
+          ]
         elsif profile_type == Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_STORE || profile_type == Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_STORE
-          certificates = Spaceship.certificate.mac_app_distribution.all +
-                         Spaceship.certificate.apple_distribution.all
+          types = [
+            Spaceship::ConnectAPI::Certificate::CertificateType::DISTRIBUTION,
+            Spaceship::ConnectAPI::Certificate::CertificateType::MAC_APP_DISTRIBUTION
+          ]
         elsif profile_type == Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_DIRECT || profile_type == Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_DIRECT
-          certificates = Spaceship.certificate.developer_id_application.all
+          types = [
+            Spaceship::ConnectAPI::Certificate::CertificateType::DEVELOPER_ID_APPLICATION
+          ]
         else
-          certificates = Spaceship.certificate.mac_app_distribution.all +
-                         Spaceship.certificate.apple_distribution.all
+          types = [
+            Spaceship::ConnectAPI::Certificate::CertificateType::DISTRIBUTION,
+            Spaceship::ConnectAPI::Certificate::CertificateType::MAC_APP_DISTRIBUTION
+          ]
         end
       end
 
-      certificates
+      fetch_certificates(types)
     end
 
     def devices_to_use
       # Only use devices if development or adhoc
       return [] if !Sigh.config[:development] && !Sigh.config[:adhoc]
 
-      device_class = case Sigh.config[:platform].to_s
-                     when 'ios'
-                       [
-                         Spaceship::ConnectAPI::Device::DeviceClass::APPLE_WATCH,
-                         Spaceship::ConnectAPI::Device::DeviceClass::IPAD,
-                         Spaceship::ConnectAPI::Device::DeviceClass::IPHONE,
-                         Spaceship::ConnectAPI::Device::DeviceClass::IPOD
-                       ].join(",")
-                     when 'tvos'
-                       Spaceship::ConnectAPI::Device::DeviceClass::APPLE_TV
-                     when 'macos', 'catalyst'
-                       Spaceship::ConnectAPI::Device::DeviceClass::MAC
-                     end
-
-      filter = { deviceClass: device_class }
-      return Spaceship::ConnectAPI::Device.all(filter: filter)
+      device_classes = case Sigh.config[:platform].to_s
+                       when 'ios'
+                         [
+                           Spaceship::ConnectAPI::Device::DeviceClass::APPLE_WATCH,
+                           Spaceship::ConnectAPI::Device::DeviceClass::IPAD,
+                           Spaceship::ConnectAPI::Device::DeviceClass::IPHONE,
+                           Spaceship::ConnectAPI::Device::DeviceClass::IPOD
+                         ]
+                       when 'tvos'
+                         [Spaceship::ConnectAPI::Device::DeviceClass::APPLE_TV]
+                       when 'macos', 'catalyst'
+                         [Spaceship::ConnectAPI::Device::DeviceClass::MAC]
+                       end
+
+      if api_token
+        return Spaceship::ConnectAPI::Device.all.select do |device|
+          device_classes.include?(device.device_class)
+        end
+      else
+        filter = { deviceClass: device_classes.join(",") }
+        return Spaceship::ConnectAPI::Device.all(filter: filter)
+      end
     end
 
     # Certificate to use based on the current distribution mode
@@ -273,7 +314,8 @@ module Sigh
         unless Sigh.config[:skip_certificate_verification]
           certificates = certificates.find_all do |c|
             file = Tempfile.new('cert')
-            file.write(c.download_raw)
+            raw_data = Base64.decode64(c.certificate_content)
+            file.write(raw_data)
             file.close
 
             FastlaneCore::CertChecker.installed?(file.path)