fastlane 2.152.0 → 2.155.1

data/match/lib/match/runner.rb

@@ -40,6 +40,7 @@ module Match
         clone_branch_directly: params[:clone_branch_directly],
         git_basic_authorization: params[:git_basic_authorization],
         git_bearer_authorization: params[:git_bearer_authorization],
+        git_private_key: params[:git_private_key],
         type: params[:type].to_s,
         generate_apple_certs: params[:generate_apple_certs],
         platform: params[:platform].to_s,
@@ -206,20 +207,26 @@ module Match
       return File.basename(cert_path).gsub(".cer", "") # Certificate ID
     end
 
+    # rubocop:disable Metrics/PerceivedComplexity
     # @return [String] The UUID of the provisioning profile so we can verify it with the Apple Developer Portal
     def fetch_provisioning_profile(params: nil, certificate_id: nil, app_identifier: nil, working_directory: nil)
       prov_type = Match.profile_type_sym(params[:type])
 
       names = [Match::Generator.profile_type_name(prov_type), app_identifier]
-      if params[:platform].to_s == :tvos.to_s
+      if params[:platform].to_s == :tvos.to_s || params[:platform].to_s == :catalyst.to_s
         names.push(params[:platform])
       end
 
       profile_name = names.join("_").gsub("*", '\*') # this is important, as it shouldn't be a wildcard
       base_dir = File.join(prefixed_working_directory, "profiles", prov_type.to_s)
 
-      extension = params[:platform].to_s == :macos.to_s ? ".provisionprofile" : ".mobileprovision"
-      profiles = Dir[File.join(base_dir, "#{profile_name}#{extension}")]
+      extension = ".mobileprovision"
+      if [:macos.to_s, :catalyst.to_s].include?(params[:platform].to_s)
+        extension = ".provisionprofile"
+      end
+
+      profile_file = "#{profile_name}#{extension}"
+      profiles = Dir[File.join(base_dir, profile_file)]
       if Helper.mac?
         keychain_path = FastlaneCore::Helper.keychain_path(params[:keychain_name]) unless params[:keychain_name].nil?
       end
@@ -241,7 +248,7 @@ module Match
 
       if profile.nil? || force
         if params[:readonly]
-          UI.error("No matching provisioning profiles found for '#{profile_name}'")
+          UI.error("No matching provisioning profiles found for '#{profile_file}'")
           UI.error("A new one cannot be created because you enabled `readonly`")
           if Dir.exist?(base_dir) # folder for `prov_type` does not exist on first match use for that type
             all_profiles = Dir.entries(base_dir).reject { |f| f.start_with?(".") }
@@ -302,6 +309,7 @@ module Match
 
       return uuid
     end
+    # rubocop:enable Metrics/PerceivedComplexity
 
     def device_count_different?(profile: nil, keychain_path: nil, platform: nil)
       return false unless profile
@@ -319,7 +327,7 @@ module Match
             Spaceship.device.all_ios_profile_devices.count
           when :tvos
             Spaceship.device.all_apple_tvs.count
-          when :mac
+          when :mac, :catalyst
             Spaceship.device.all_macs.count
           else
             Spaceship.device.all.count

data/match/lib/match/spaceship_ensure.rb

@@ -46,6 +46,10 @@ module Match
     end
 
     def certificates_exists(username: nil, certificate_ids: [], platform: nil)
+      if platform == :catalyst.to_s
+        platform = :macos.to_s
+      end
+
       Spaceship.certificate.all(mac: platform == "macos").each do |cert|
         certificate_ids.delete(cert.id)
       end
@@ -61,18 +65,12 @@ module Match
     end
 
     def profile_exists(username: nil, uuid: nil, platform: nil)
-      is_mac = platform == "macos"
-      found = Spaceship.provisioning_profile.all(mac: is_mac).find do |profile|
+      # App Store Connect API does not allow filter of profile by platform or uuid (as of 2020-07-30)
+      # Need to fetch all profiles and search for uuid on client side
+      found = Spaceship::ConnectAPI::Profile.all.find do |profile|
         profile.uuid == uuid
       end
 
-      # Look for iOS after looking for macOS (needed for Catalyst apps)
-      if !found && is_mac
-        found = Spaceship.provisioning_profile.all(mac: false).find do |profile|
-          profile.uuid == uuid
-        end
-      end
-
       unless found
         UI.error("Provisioning profile '#{uuid}' is not available on the Developer Portal for the user #{username}, fixing this now for you 🔨")
         return false

data/match/lib/match/storage/git_storage.rb

@@ -19,6 +19,7 @@ module Match
       attr_accessor :platform
       attr_accessor :git_basic_authorization
       attr_accessor :git_bearer_authorization
+      attr_accessor :git_private_key
 
       def self.configure(params)
         return self.new(
@@ -32,7 +33,8 @@ module Match
           git_user_email: params[:git_user_email],
           clone_branch_directly: params[:clone_branch_directly],
           git_basic_authorization: params[:git_basic_authorization],
-          git_bearer_authorization: params[:git_bearer_authorization]
+          git_bearer_authorization: params[:git_bearer_authorization],
+          git_private_key: params[:git_private_key]
         )
       end
 
@@ -46,7 +48,8 @@ module Match
                      git_user_email: nil,
                      clone_branch_directly: false,
                      git_basic_authorization: nil,
-                     git_bearer_authorization: nil)
+                     git_bearer_authorization: nil,
+                     git_private_key: nil)
         self.git_url = git_url
         self.shallow_clone = shallow_clone
         self.skip_docs = skip_docs
@@ -56,6 +59,7 @@ module Match
         self.clone_branch_directly = clone_branch_directly
         self.git_basic_authorization = git_basic_authorization
         self.git_bearer_authorization = git_bearer_authorization
+        self.git_private_key = git_private_key
 
         self.type = type if type
         self.platform = platform if platform
@@ -85,6 +89,16 @@ module Match
           command += " -b #{self.branch.shellescape} --single-branch"
         end
 
+        unless self.git_private_key.nil?
+          if File.file?(self.git_private_key)
+            ssh_add = File.expand_path(self.git_private_key).shellescape.to_s
+          else
+            UI.message("Private key file does not exist, will continue by using it as a raw key.")
+            ssh_add = "- <<< \"#{self.git_private_key}\""
+          end
+          command = "ssh-agent bash -c 'ssh-add #{ssh_add}; #{command}'"
+        end
+
         UI.message("Cloning remote git repo...")
         if self.branch && !self.clone_branch_directly
           UI.message("If cloning the repo takes too long, you can use the `clone_branch_directly` option in match.")

data/match/lib/match/storage/google_cloud_storage.rb

@@ -213,7 +213,7 @@ module Match
 
         return DEFAULT_KEYS_FILE_NAME if File.exist?(DEFAULT_KEYS_FILE_NAME)
 
-        fastlane_folder_gc_keys_path = File.join(FastlaneCore::FastlaneFolder.path, DEFAULT_KEYS_FILE_NAME)
+        fastlane_folder_gc_keys_path = File.join(FastlaneCore::FastlaneFolder.path || Dir.pwd, DEFAULT_KEYS_FILE_NAME)
         return fastlane_folder_gc_keys_path if File.exist?(fastlane_folder_gc_keys_path)
 
         if google_cloud_project_id.to_s.length > 0

data/pilot/lib/pilot/build_manager.rb

@@ -281,8 +281,17 @@ module Pilot
       changelog
     end
 
+    def self.strip_less_than_sign(changelog)
+      if changelog && changelog.include?("<")
+        changelog.delete!("<")
+        UI.important("Less than signs (<) have been removed from the changelog, since they're not allowed by Apple.")
+      end
+      changelog
+    end
+
     def self.sanitize_changelog(changelog)
       changelog = strip_emoji(changelog)
+      changelog = strip_less_than_sign(changelog)
       truncate_changelog(changelog)
     end
 

data/pilot/lib/pilot/options.rb

@@ -122,7 +122,7 @@ module Pilot
                                      short_option: "-w",
                                      optional: true,
                                      env_name: "PILOT_CHANGELOG",
-                                     description: "Provide the 'What to Test' text when uploading a new build. `skip_waiting_for_build_processing: false` is required to set the changelog"),
+                                     description: "Provide the 'What to Test' text when uploading a new build"),
         FastlaneCore::ConfigItem.new(key: :skip_submission,
                                      short_option: "-s",
                                      env_name: "PILOT_SKIP_SUBMISSION",

data/scan/lib/scan/runner.rb

@@ -39,12 +39,7 @@ module Scan
         end
       end
 
-      # We call this method, to be sure that all other simulators are killed
-      # And a correct one is freshly launched. Switching between multiple simulator
-      # in case the user specified multiple targets works with no issues
-      # This way it's okay to just call it for the first simulator we're using for
-      # the first test run
-      FastlaneCore::Simulator.launch(Scan.devices.first) if Scan.devices && Scan.config[:prelaunch_simulator]
+      prelaunch_simulators
 
       if Scan.config[:reinstall_app]
         app_identifier = Scan.config[:app_identifier]
@@ -165,6 +160,24 @@ module Scan
       File.read(Scan.cache[:temp_junit_report])
     end
 
+    def prelaunch_simulators
+      return unless Scan.devices.to_a.size > 0 # no devices selected, no sims to launch
+
+      # Return early unless the user wants to prelaunch simulators. Or if the user wants simulator logs
+      # then we must prelaunch simulators because Xcode's headless
+      # mode launches and shutsdown the simulators before we can collect the logs.
+      return unless Scan.config[:prelaunch_simulator] || Scan.config[:include_simulator_logs]
+
+      devices_to_shutdown = []
+      Scan.devices.each do |device|
+        devices_to_shutdown << device if device.state == "Shutdown"
+        device.boot
+      end
+      at_exit do
+        devices_to_shutdown.each(&:shutdown)
+      end
+    end
+
     def copy_simulator_logs
       return unless Scan.config[:include_simulator_logs]
 

data/sigh/lib/sigh/download_all.rb

@@ -1,5 +1,7 @@
 require 'spaceship'
 
+require 'base64'
+
 require_relative 'manager'
 require_relative 'module'
 
@@ -12,35 +14,43 @@ module Sigh
       Spaceship.select_team
       UI.message("Successfully logged in")
 
+      if download_xcode_profiles
+        UI.deprecated("The App Store Connect API does not support querying for Xcode managed profiles: --download_code_profiles is deprecated")
+      end
+
       case Sigh.config[:platform].to_s
       when 'ios'
-        download_profiles(Spaceship.provisioning_profile.all(xcode: download_xcode_profiles))
-        xcode_profiles_downloaded?(xcode: download_xcode_profiles, supported: true)
+        profile_types = [
+          Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_STORE,
+          Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_INHOUSE,
+          Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_ADHOC,
+          Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_DEVELOPMENT
+        ]
       when 'macos'
-        download_profiles(Spaceship.provisioning_profile.all(mac: true, xcode: download_xcode_profiles))
-        xcode_profiles_downloaded?(xcode: download_xcode_profiles, supported: true)
+        profile_types = [
+          Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_STORE,
+          Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_DEVELOPMENT,
+          Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_DIRECT
+        ]
+      when 'catalyst'
+        profile_types = [
+          Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_STORE,
+          Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_DEVELOPMENT,
+          Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_DIRECT
+        ]
       when 'tvos'
-        download_profiles(Spaceship.provisioning_profile.all_tvos)
-        xcode_profiles_downloaded?(xcode: download_xcode_profiles, supported: false)
+        profile_types = [
+          Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_STORE,
+          Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_INHOUSE,
+          Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_ADHOC,
+          Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_DEVELOPMENT
+        ]
       end
-    end
-
-    # @param xcode [Bool] Whether or not the user passed the download_xcode_profiles flag
-    # @param supported [Bool] Whether or not this platform supports downloading xcode profiles at all
-    def xcode_profiles_downloaded?(xcode: false, supported: false)
-      if supported
-        if xcode
-          UI.message("This run also included all Xcode managed provisioning profiles, as you used the `--download_xcode_profiles` flag")
-        elsif !xcode
-          UI.message("All Xcode managed provisioning profiles were ignored on this, to include them use the `--download_xcode_profiles` flag")
-        end
 
-      elsif !supported
-        if xcode
-          UI.important("Downloading Xcode managed profiles is not supported for platform #{Sigh.config[:platform]}")
-          return
-        end
-      end
+      # Filtering on 'profileType' seems to be undocumented as of 2020-07-30
+      # but works on both web session and official API
+      profiles = Spaceship::ConnectAPI::Profile.all(filter: { profileType: profile_types.join(",") }, includes: "bundleId")
+      download_profiles(profiles)
     end
 
     # @param profiles [Array] Array of all the provisioning profiles we want to download
@@ -57,18 +67,22 @@ module Sigh
       end
     end
 
+    def pretty_type(profile_type)
+      return Sigh.profile_pretty_type(profile_type)
+    end
+
     # @param profile [ProvisioningProfile] A profile we plan to download and store
     def download_profile(profile)
       FileUtils.mkdir_p(Sigh.config[:output_path])
 
-      type_name = profile.class.pretty_type
-      profile_name = "#{type_name}_#{profile.uuid}_#{profile.app.bundle_id}"
+      type_name = pretty_type(profile.profile_type)
+      profile_name = "#{type_name}_#{profile.uuid}_#{profile.bundle_id.identifier}"
 
       if Sigh.config[:platform].to_s == 'tvos'
         profile_name += "_tvos"
       end
 
-      if Sigh.config[:platform].to_s == 'macos'
+      if ['macos', 'catalyst'].include?(Sigh.config[:platform].to_s)
         profile_name += '.provisionprofile'
       else
         profile_name += '.mobileprovision'
@@ -76,7 +90,8 @@ module Sigh
 
       output_path = File.join(Sigh.config[:output_path], profile_name)
       File.open(output_path, "wb") do |f|
-        f.write(profile.download)
+        content = Base64.decode64(profile.profile_content)
+        f.write(content)
       end
 
       Manager.install_profile(output_path) unless Sigh.config[:skip_install]

data/sigh/lib/sigh/module.rb

@@ -5,6 +5,32 @@ module Sigh
   # Use this to just setup the configuration attribute and set it later somewhere else
   class << self
     attr_accessor :config
+
+    def profile_pretty_type(profile_type)
+      require 'spaceship'
+
+      case profile_type
+      when Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_DEVELOPMENT,
+        Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_DEVELOPMENT,
+        Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_DEVELOPMENT,
+        Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_DEVELOPMENT
+        "Development"
+      when Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_STORE,
+        Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_STORE,
+        Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_STORE,
+        Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_STORE
+        "AppStore"
+      when Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_ADHOC,
+        Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_ADHOC
+        "AdHoc"
+      when Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_INHOUSE,
+        Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_INHOUSE
+        "InHouse"
+      when Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_DIRECT,
+        Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_DIRECT
+        "Direct"
+      end
+    end
   end
 
   Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore

data/sigh/lib/sigh/options.rb

@@ -131,12 +131,12 @@ module Sigh
         FastlaneCore::ConfigItem.new(key: :platform,
                                      short_option: '-p',
                                      env_name: "SIGH_PLATFORM",
-                                     description: "Set the provisioning profile's platform (i.e. ios, tvos)",
+                                     description: "Set the provisioning profile's platform (i.e. ios, tvos, macos, catalyst)",
                                      is_string: false,
                                      default_value: "ios",
                                      verify_block: proc do |value|
                                        value = value.to_s
-                                       pt = %w(macos tvos ios)
+                                       pt = %w(macos tvos ios catalyst)
                                        UI.user_error!("Unsupported platform, must be: #{pt}") unless pt.include?(value)
                                      end),
         FastlaneCore::ConfigItem.new(key: :readonly,

data/sigh/lib/sigh/runner.rb

@@ -1,5 +1,7 @@
 require 'spaceship'
 
+require 'base64'
+
 require 'fastlane_core/print_table'
 require 'fastlane_core/cert_checker'
 require_relative 'module'
@@ -42,7 +44,7 @@ module Sigh
 
       UI.user_error!("Something went wrong fetching the latest profile") unless profile
 
-      if profile_type == Spaceship.provisioning_profile.in_house
+      if [Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_INHOUSE, Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_INHOUSE].include?(profile_type)
         ENV["SIGH_PROFILE_ENTERPRISE"] = "1"
       else
         ENV.delete("SIGH_PROFILE_ENTERPRISE")
@@ -55,11 +57,26 @@ module Sigh
     def profile_type
       return @profile_type if @profile_type
 
-      @profile_type = Spaceship.provisioning_profile.app_store
-      @profile_type = Spaceship.provisioning_profile.in_house if Spaceship.client.in_house?
-      @profile_type = Spaceship.provisioning_profile.ad_hoc if Sigh.config[:adhoc]
-      @profile_type = Spaceship.provisioning_profile.direct if Sigh.config[:developer_id]
-      @profile_type = Spaceship.provisioning_profile.development if Sigh.config[:development]
+      case Sigh.config[:platform]
+      when "ios"
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_STORE
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_INHOUSE if Spaceship.client.in_house?
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_ADHOC if Sigh.config[:adhoc]
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_DEVELOPMENT if Sigh.config[:development]
+      when "tvos"
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_STORE
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_INHOUSE if Spaceship.client.in_house?
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_ADHOC if Sigh.config[:adhoc]
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_DEVELOPMENT if Sigh.config[:development]
+      when "macos"
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_STORE
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_DEVELOPMENT if Sigh.config[:development]
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::MAC_APP_DIRECT if Sigh.config[:developer_id]
+      when "catalyst"
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_STORE
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_DEVELOPMENT if Sigh.config[:development]
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::MAC_CATALYST_APP_DIRECT if Sigh.config[:developer_id]
+      end
 
       @profile_type
     end
@@ -67,9 +84,13 @@ module Sigh
     # Fetches a profile matching the user's search requirements
     def fetch_profiles
       UI.message("Fetching profiles...")
-      results = profile_type.find_by_bundle_id(bundle_id: Sigh.config[:app_identifier],
-                                                     mac: Sigh.config[:platform].to_s == 'macos',
-                                            sub_platform: Sigh.config[:platform].to_s == 'tvos' ? 'tvOS' : nil)
+
+      # Filtering on 'profileType' seems to be undocumented as of 2020-07-30
+      # but works on both web session and official API
+      results = Spaceship::ConnectAPI::Profile.all(filter: { profileType: profile_type }, includes: "bundleId,certificates").select do |profile|
+        profile.bundle_id.identifier == Sigh.config[:app_identifier]
+      end
+
       results = results.find_all do |current_profile|
         if current_profile.valid? || Sigh.config[:force]
           true
@@ -93,7 +114,7 @@ module Sigh
         # "member" and not an a "admin"
         raw_certs = current_profile.certificates.map do |cert|
           begin
-            raw_cert = cert.download_raw
+            raw_cert = Base64.decode64(cert.certificate_content)
           rescue => error
             UI.important("Cannot download cert #{cert.id} - #{error.message}")
             raw_cert = nil
@@ -114,31 +135,46 @@ module Sigh
             UI.message("Certificate for Provisioning Profile '#{current_profile.name}' not available locally: #{current_cert[:cert].id}, skipping this one...")
           end
         end
-        installed && current_profile.certificate_valid?
+
+        # Don't need to check if certificate is valid because it comes with the
+        # profile in the response
+        installed
       end
     end
 
+    def profile_type_pretty_type
+      return Sigh.profile_pretty_type(profile_type)
+    end
+
     # Create a new profile and return it
     def create_profile!
-      cert = certificate_to_use
-      bundle_id = Sigh.config[:app_identifier]
-      name = Sigh.config[:provisioning_name] || [bundle_id, profile_type.pretty_type].join(' ')
+      app_identifier = Sigh.config[:app_identifier]
+      name = Sigh.config[:provisioning_name] || [app_identifier, profile_type_pretty_type].join(' ')
 
       unless Sigh.config[:skip_fetch_profiles]
-        if Spaceship.provisioning_profile.all(mac: Sigh.config[:platform].to_s == 'macos').find { |p| p.name == name }
+        profile = Spaceship::ConnectAPI::Profile.all.find { |p| p.name == name }
+        if profile
           UI.user_error!("The name '#{name}' is already taken, and fail_on_name_taken is true") if Sigh.config[:fail_on_name_taken]
           UI.error("The name '#{name}' is already taken, using another one.")
           name += " #{Time.now.to_i}"
         end
       end
 
+      bundle_id = Spaceship::ConnectAPI::BundleId.find(app_identifier)
+      unless bundle_id
+        UI.user_error!("Could not find App with App Identifier '#{Sigh.config[:app_identifier]}'")
+      end
+
       UI.important("Creating new provisioning profile for '#{Sigh.config[:app_identifier]}' with name '#{name}' for '#{Sigh.config[:platform]}' platform")
-      profile = profile_type.create!(name: name,
-                                bundle_id: bundle_id,
-                              certificate: cert,
-                                      mac: Sigh.config[:platform].to_s == 'macos',
-                             sub_platform: Sigh.config[:platform].to_s == 'tvos' ? 'tvOS' : nil,
-                            template_name: Sigh.config[:template_name])
+
+      profile = Spaceship::ConnectAPI::Profile.create(
+        name: name,
+        profile_type: profile_type,
+        bundle_id_id: bundle_id.id,
+        certificate_ids: certificates_to_use.map(&:id),
+        device_ids: devices_to_use.map(&:id)
+      )
+
       profile
     end
 
@@ -155,16 +191,16 @@ module Sigh
     def certificates_for_profile_and_platform
       case Sigh.config[:platform].to_s
       when 'ios', 'tvos'
-        if profile_type == Spaceship.provisioning_profile.Development
+        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
-        elsif profile_type == Spaceship.provisioning_profile.InHouse
+        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
         # 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.provisioning_profile.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.client && Spaceship.client.in_house?
           # Enterprise accounts don't have access to Apple Distribution certificates
           certificates = Spaceship.certificate.in_house.all
         else
@@ -173,14 +209,14 @@ module Sigh
                          Spaceship.certificate.apple_distribution.all
         end
 
-      when 'macos'
-        if profile_type == Spaceship.provisioning_profile.Development
+      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
-        elsif profile_type == Spaceship.provisioning_profile.AppStore
+        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
-        elsif profile_type == Spaceship.provisioning_profile.Direct
+        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
         else
           certificates = Spaceship.certificate.mac_app_distribution.all +
@@ -191,8 +227,27 @@ module Sigh
       certificates
     end
 
+    def devices_to_use
+      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)
+    end
+
     # Certificate to use based on the current distribution mode
-    def certificate_to_use
+    def certificates_to_use
       certificates = certificates_for_profile_and_platform
 
       # Filter them
@@ -235,26 +290,28 @@ module Sigh
         filters << "Owner Name: '#{Sigh.config[:cert_owner_name]}' " if Sigh.config[:cert_owner_name]
         filters << "Certificate ID: '#{Sigh.config[:cert_id]}' " if Sigh.config[:cert_id]
         UI.important("No certificates for filter: #{filters}") if filters.length > 0
-        message = "Could not find a matching code signing identity for type '#{profile_type.to_s.split(':').last}'. "
+        message = "Could not find a matching code signing identity for type '#{profile_type_pretty_type}'. "
         message += "It is recommended to use match to manage code signing for you, more information on https://codesigning.guide. "
         message += "If you don't want to do so, you can also use cert to generate a new one: https://fastlane.tools/cert"
         UI.user_error!(message)
       end
 
       return certificates if Sigh.config[:development] # development profiles support multiple certificates
-      return certificates.first
+      return [certificates.first]
     end
 
     # Downloads and stores the provisioning profile
     def download_profile(profile)
       UI.important("Downloading provisioning profile...")
-      profile_name ||= "#{profile_type.pretty_type}_#{Sigh.config[:app_identifier]}"
+      profile_name ||= "#{profile_type_pretty_type}_#{Sigh.config[:app_identifier]}"
 
       if Sigh.config[:platform].to_s == 'tvos'
         profile_name += "_tvos"
+      elsif Sigh.config[:platform].to_s == 'catalyst'
+        profile_name += "_catalyst"
       end
 
-      if Sigh.config[:platform].to_s == 'macos'
+      if ['macos', 'catalyst'].include?(Sigh.config[:platform].to_s)
         profile_name += '.provisionprofile'
       else
         profile_name += '.mobileprovision'
@@ -263,7 +320,8 @@ module Sigh
       tmp_path = Dir.mktmpdir("profile_download")
       output_path = File.join(tmp_path, profile_name)
       File.open(output_path, "wb") do |f|
-        f.write(profile.download)
+        content = Base64.decode64(profile.profile_content)
+        f.write(content)
       end
 
       UI.success("Successfully downloaded provisioning profile...")
@@ -272,7 +330,10 @@ module Sigh
 
     # Makes sure the current App ID exists. If not, it will show an appropriate error message
     def ensure_app_exists!
-      return if Spaceship::App.find(Sigh.config[:app_identifier], mac: Sigh.config[:platform].to_s == 'macos')
+      # Only ensuring by app identifier
+      # We used to ensure by platform (IOS and MAC_OS) but now apps are
+      # always UNIVERSAL as of 2020-07-30
+      return if Spaceship::ConnectAPI::BundleId.find(Sigh.config[:app_identifier])
       print_produce_command(Sigh.config)
       UI.user_error!("Could not find App with App Identifier '#{Sigh.config[:app_identifier]}'")
     end