fastlane 2.173.0 → 2.194.0

data/gym/lib/gym/generators/package_command_generator_xcode7.rb

@@ -4,6 +4,7 @@
 # because of
 # `incompatible encoding regexp match (UTF-8 regexp with ASCII-8BIT string) (Encoding::CompatibilityError)`
 
+require 'addressable/uri'
 require 'tempfile'
 require 'xcodeproj'
 
@@ -81,28 +82,33 @@ module Gym
         Gym.cache[:ipa_path]
       end
 
-      def pkg_path
-        path = Gym.cache[:pkg_path]
+      def binary_path
+        path = Gym.cache[:binary_path]
         return path if path
 
         path = Dir[File.join(temporary_output_path, "*.pkg")].last
-        # We need to process generic PKG
+        app_path = Dir[File.join(temporary_output_path, "*.app")].last
+        # We need to process generic PKG or APP
         if path
           # Try to find PKG file in the output directory, used when app thinning was not set
-          Gym.cache[:pkg_path] = File.join(temporary_output_path, "#{Gym.config[:output_name]}.pkg")
-          FileUtils.mv(path, Gym.cache[:pkg_path]) unless File.expand_path(path).casecmp(File.expand_path(Gym.cache[:pkg_path]).downcase).zero?
+          Gym.cache[:binary_path] = File.join(temporary_output_path, "#{Gym.config[:output_name]}.pkg")
+          FileUtils.mv(path, Gym.cache[:binary_path]) unless File.expand_path(path).casecmp(File.expand_path(Gym.cache[:binary_path]).downcase).zero?
         elsif Dir.exist?(apps_path)
           # Try to find "generic" PKG file inside "Apps" folder, used when app thinning was set
           files = Dir[File.join(apps_path, "*.pkg")]
           # Generic PKG file doesn't have suffix so its name is the shortest
           path = files.min_by(&:length)
-          Gym.cache[:pkg_path] = File.join(temporary_output_path, "#{Gym.config[:output_name]}.pkg")
-          FileUtils.cp(path, Gym.cache[:pkg_path]) unless File.expand_path(path).casecmp(File.expand_path(Gym.cache[:pkg_path]).downcase).zero?
+          Gym.cache[:binary_path] = File.join(temporary_output_path, "#{Gym.config[:output_name]}.pkg")
+          FileUtils.cp(path, Gym.cache[:binary_path]) unless File.expand_path(path).casecmp(File.expand_path(Gym.cache[:binary_path]).downcase).zero?
+        elsif app_path
+          # Try to find .app file in the output directory. This is used when macOS is set and .app is being generated.
+          Gym.cache[:binary_path] = File.join(temporary_output_path, "#{Gym.config[:output_name]}.app")
+          FileUtils.mv(app_path, Gym.cache[:binary_path]) unless File.expand_path(app_path).casecmp(File.expand_path(Gym.cache[:binary_path]).downcase).zero?
         else
           ErrorHandler.handle_empty_pkg unless path
         end
 
-        Gym.cache[:pkg_path]
+        Gym.cache[:binary_path]
       end
 
       # The path the the dsym file for this app. Might be nil
@@ -149,12 +155,12 @@ module Gym
 
       def normalize_export_options(hash)
         # Normalize some values
-        hash[:onDemandResourcesAssetPacksBaseURL] = URI.escape(hash[:onDemandResourcesAssetPacksBaseURL]) if hash[:onDemandResourcesAssetPacksBaseURL]
+        hash[:onDemandResourcesAssetPacksBaseURL] = Addressable::URI.encode(hash[:onDemandResourcesAssetPacksBaseURL]) if hash[:onDemandResourcesAssetPacksBaseURL]
         if hash[:manifest]
-          hash[:manifest][:appURL] = URI.escape(hash[:manifest][:appURL]) if hash[:manifest][:appURL]
-          hash[:manifest][:displayImageURL] = URI.escape(hash[:manifest][:displayImageURL]) if hash[:manifest][:displayImageURL]
-          hash[:manifest][:fullSizeImageURL] = URI.escape(hash[:manifest][:fullSizeImageURL]) if hash[:manifest][:fullSizeImageURL]
-          hash[:manifest][:assetPackManifestURL] = URI.escape(hash[:manifest][:assetPackManifestURL]) if hash[:manifest][:assetPackManifestURL]
+          hash[:manifest][:appURL] = Addressable::URI.encode(hash[:manifest][:appURL]) if hash[:manifest][:appURL]
+          hash[:manifest][:displayImageURL] = Addressable::URI.encode(hash[:manifest][:displayImageURL]) if hash[:manifest][:displayImageURL]
+          hash[:manifest][:fullSizeImageURL] = Addressable::URI.encode(hash[:manifest][:fullSizeImageURL]) if hash[:manifest][:fullSizeImageURL]
+          hash[:manifest][:assetPackManifestURL] = Addressable::URI.encode(hash[:manifest][:assetPackManifestURL]) if hash[:manifest][:assetPackManifestURL]
         end
         hash
       end

data/gym/lib/gym/runner.rb

@@ -243,12 +243,16 @@ module Gym
     # Moves over the binary and dsym file to the output directory
     # @return (String) The path to the resulting pkg file
     def move_pkg
-      FileUtils.mv(PackageCommandGenerator.pkg_path, File.expand_path(Gym.config[:output_directory]), force: true)
-      pkg_path = File.expand_path(File.join(Gym.config[:output_directory], File.basename(PackageCommandGenerator.pkg_path)))
+      binary_path = File.expand_path(File.join(Gym.config[:output_directory], File.basename(PackageCommandGenerator.binary_path)))
+      if File.exist?(binary_path)
+        UI.important(" Removing #{File.basename(binary_path)}") if FastlaneCore::Globals.verbose?
+        FileUtils.rm_rf(binary_path)
+      end
+      FileUtils.mv(PackageCommandGenerator.binary_path, File.expand_path(Gym.config[:output_directory]), force: true)
 
       UI.success("Successfully exported and signed the pkg file:")
-      UI.message(pkg_path)
-      pkg_path
+      UI.message(binary_path)
+      binary_path
     end
 
     # copys framework from temp folder:
@@ -274,6 +278,13 @@ module Gym
       exe_name = Gym.project.build_settings(key: "EXECUTABLE_NAME")
       app_path = File.join(BuildCommandGenerator.archive_path, "Products/Applications/#{exe_name}.app")
 
+      unless File.exist?(app_path)
+        # Apparently the `EXECUTABLE_NAME` is not correct. This can happen when building a workspace which has a project
+        # earlier in the build order that has a different `EXECUTABLE_NAME` than the app. Try to find the last `.app` as
+        # a fallback for this situation.
+        app_path = Dir[File.join(BuildCommandGenerator.archive_path, "Products", "Applications", "*.app")].last
+      end
+
       UI.crash!("Couldn't find application in '#{BuildCommandGenerator.archive_path}'") unless File.exist?(app_path)
 
       joined_app_path = File.join(Gym.config[:output_directory], File.basename(app_path))

data/match/lib/match/change_password.rb

@@ -16,7 +16,7 @@ module Match
 
       ensure_ui_interactive
 
-      to = FastlaneCore::Helper.ask_password(message: "New passphrase for Git Repo: ", confirm: true)
+      new_password = FastlaneCore::Helper.ask_password(message: "New passphrase for Git Repo: ", confirm: true)
 
       # Choose the right storage and encryption implementations
       storage = Storage.for_mode(params[:storage_mode], {
@@ -37,10 +37,10 @@ module Match
       encryption.decrypt_files
 
       encryption.clear_password
-      encryption.store_password(to)
+      encryption.store_password(new_password)
 
       message = "[fastlane] Changed passphrase"
-      files_to_commit = encryption.encrypt_files
+      files_to_commit = encryption.encrypt_files(password: new_password)
       storage.save_changes!(files_to_commit: files_to_commit, custom_message: message)
     end
 

data/match/lib/match/commands_generator.rb

@@ -1,6 +1,7 @@
 require 'commander'
 
 require 'fastlane_core/configuration/configuration'
+require 'fastlane_core/ui/help_formatter'
 
 require_relative 'nuke'
 require_relative 'change_password'
@@ -32,7 +33,7 @@ module Match
       program :help, 'Author', 'Felix Krause <match@krausefx.com>'
       program :help, 'Website', 'https://fastlane.tools'
       program :help, 'Documentation', 'https://docs.fastlane.tools/actions/match/'
-      program :help_formatter, :compact
+      program :help_formatter, FastlaneCore::HelpFormatter
 
       global_option('--verbose') { FastlaneCore::Globals.verbose = true }
       global_option('--env STRING[,STRING2]', String, 'Add environment(s) to use with `dotenv`')

data/match/lib/match/encryption/interface.rb

@@ -3,7 +3,7 @@ module Match
     class Interface
       # Call this method to trigger the actual
       # encryption
-      def encrypt_files
+      def encrypt_files(password: nil)
         not_implemented(__method__)
       end
 

data/match/lib/match/encryption/openssl.rb

@@ -28,9 +28,9 @@ module Match
         self.working_directory = working_directory
       end
 
-      def encrypt_files
+      def encrypt_files(password: nil)
         files = []
-        password = fetch_password!
+        password ||= fetch_password!
         iterate(self.working_directory) do |current|
           files << current
           encrypt_specific_file(path: current, password: password)

data/match/lib/match/importer.rb

@@ -22,6 +22,9 @@ module Match
         git_branch: params[:git_branch],
         git_full_name: params[:git_full_name],
         git_user_email: params[:git_user_email],
+        git_private_key: params[:git_private_key],
+        git_basic_authorization: params[:git_basic_authorization],
+        git_bearer_authorization: params[:git_bearer_authorization],
         clone_branch_directly: params[:clone_branch_directly],
         type: params[:type].to_s,
         platform: params[:platform].to_s,
@@ -93,15 +96,17 @@ module Match
         dest_cert_path = File.join(output_dir_certs, "#{cert_name}.cer")
         dest_p12_path = File.join(output_dir_certs, "#{p12_name}.p12")
       else
-        # Need to get the cert id by comparing base64 encoded cert content with certificate content from the API responses
-        token = api_token(params)
-        if token
+        if (api_token = Spaceship::ConnectAPI::Token.from(hash: params[:api_key], filepath: params[:api_key_path]))
           UI.message("Creating authorization token for App Store Connect API")
-          Spaceship::ConnectAPI.token = token
+          Spaceship::ConnectAPI.token = api_token
+        elsif !Spaceship::ConnectAPI.token.nil?
+          UI.message("Using existing authorization token for App Store Connect API")
         else
           UI.message("Login to App Store Connect (#{params[:username]})")
           Spaceship::ConnectAPI.login(params[:username], use_portal: true, use_tunes: false, portal_team_id: params[:team_id], team_name: params[:team_name])
         end
+
+        # Need to get the cert id by comparing base64 encoded cert content with certificate content from the API responses
         certs = Spaceship::ConnectAPI::Certificate.all(filter: { certificateType: certificate_type })
 
         # Base64 encode contents to find match from API to find a cert ID
@@ -147,11 +152,5 @@ module Match
       UI.user_error!("#{file_description} does not exist at path: #{file_path}") unless !file_path.nil? || optional
       file_path
     end
-
-    def api_token(params)
-      @api_token ||= Spaceship::ConnectAPI::Token.create(params[:api_key]) if params[:api_key]
-      @api_token ||= Spaceship::ConnectAPI::Token.from_json_file(params[:api_key_path]) if params[:api_key_path]
-      return @api_token
-    end
   end
 end

data/match/lib/match/migrate.rb

@@ -91,9 +91,8 @@ module Match
     end
 
     def api_token(params)
-      @api_token ||= Spaceship::ConnectAPI::Token.create(params[:api_key]) if params[:api_key]
-      @api_token ||= Spaceship::ConnectAPI::Token.from_json_file(params[:api_key_path]) if params[:api_key_path]
-      return @api_token
+      api_token = Spaceship::ConnectAPI::Token.from(hash: params[:api_key], filepath: params[:api_key_path])
+      return api_token
     end
 
     def ensure_parameters_are_valid(params)

data/match/lib/match/module.rb

@@ -21,6 +21,7 @@ module Match
   end
 
   def self.cert_type_sym(type)
+    type = type.to_s
     return :mac_installer_distribution if type == "mac_installer_distribution"
     return :developer_id_installer if type == "developer_id_installer"
     return :developer_id_application if type == "developer_id"

data/match/lib/match/nuke.rb

@@ -36,6 +36,11 @@ module Match
         git_branch: params[:git_branch],
         git_full_name: params[:git_full_name],
         git_user_email: params[:git_user_email],
+
+        git_private_key: params[:git_private_key],
+        git_basic_authorization: params[:git_basic_authorization],
+        git_bearer_authorization: params[:git_bearer_authorization],
+
         clone_branch_directly: params[:clone_branch_directly],
         google_cloud_bucket_name: params[:google_cloud_bucket_name].to_s,
         google_cloud_keys_file: params[:google_cloud_keys_file].to_s,
@@ -97,9 +102,11 @@ module Match
     end
 
     def spaceship_login
-      if api_token
+      if (api_token = Spaceship::ConnectAPI::Token.from(hash: params[:api_key], filepath: params[:api_key_path]))
         UI.message("Creating authorization token for App Store Connect API")
         Spaceship::ConnectAPI.token = api_token
+      elsif !Spaceship::ConnectAPI.token.nil?
+        UI.message("Using existing authorization token for App Store Connect API")
       else
         Spaceship::ConnectAPI.login(params[:username], use_portal: true, use_tunes: false, portal_team_id: params[:team_id], team_name: params[:team_name])
       end
@@ -115,12 +122,6 @@ module Match
       end
     end
 
-    def api_token
-      @api_token ||= Spaceship::ConnectAPI::Token.create(params[:api_key]) if params[:api_key]
-      @api_token ||= Spaceship::ConnectAPI::Token.from_json_file(params[:api_key_path]) if params[:api_key_path]
-      return @api_token
-    end
-
     # Collect all the certs/profiles
     def prepare_list
       UI.message("Fetching certificates and profiles...")
@@ -246,9 +247,8 @@ module Match
         UI.success("Successfully deleted certificate")
       end
 
-      if self.files.count > 0
-        files_to_delete = delete_files!
-      end
+      files_to_delete = delete_files! if self.files.count > 0
+      files_to_delete ||= []
 
       self.encryption.encrypt_files if self.encryption
 

data/match/lib/match/options.rb

@@ -74,7 +74,7 @@ module Match
 
         # App Store Connect API
         FastlaneCore::ConfigItem.new(key: :api_key_path,
-                                     env_name: "SIGH_API_KEY_PATH",
+                                     env_names: ["SIGH_API_KEY_PATH", "APP_STORE_CONNECT_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],
@@ -82,8 +82,8 @@ module Match
                                        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)",
+                                     env_names: ["SIGH_API_KEY", "APP_STORE_CONNECT_API_KEY"],
+                                     description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-hash-option)",
                                      type: Hash,
                                      optional: true,
                                      sensitive: true,
@@ -207,6 +207,7 @@ module Match
         FastlaneCore::ConfigItem.new(key: :s3_secret_access_key,
                                      env_name: "MATCH_S3_SECRET_ACCESS_KEY",
                                      description: "S3 secret access key",
+                                     sensitive: true,
                                      optional: true),
         FastlaneCore::ConfigItem.new(key: :s3_bucket,
                                      env_name: "MATCH_S3_BUCKET",
@@ -238,7 +239,7 @@ module Match
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :force_for_new_devices,
                                      env_name: "MATCH_FORCE_FOR_NEW_DEVICES",
-                                     description: "Renew the provisioning profiles if the device count on the developer portal has changed. Ignored for profile type 'appstore'",
+                                     description: "Renew the provisioning profiles if the device count on the developer portal has changed. Ignored for profile types 'appstore' and 'developer_id'",
                                      type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :skip_confirmation,

data/match/lib/match/runner.rb

@@ -139,9 +139,8 @@ module Match
     # rubocop:enable Metrics/PerceivedComplexity
 
     def api_token(params)
-      @api_token ||= Spaceship::ConnectAPI::Token.create(params[:api_key]) if params[:api_key]
-      @api_token ||= Spaceship::ConnectAPI::Token.from_json_file(params[:api_key_path]) if params[:api_key_path]
-      return @api_token
+      api_token = Spaceship::ConnectAPI::Token.from(hash: params[:api_key], filepath: params[:api_key_path])
+      return api_token
     end
 
     # Used when creating a new certificate or profile
@@ -192,12 +191,12 @@ module Match
             UI.verbose("Certificate '#{File.basename(cert_path)}' is already installed on this machine")
           else
             Utils.import(cert_path, params[:keychain_name], password: params[:keychain_password])
-          end
 
-          # Import the private key
-          # there seems to be no good way to check if it's already installed - so just install it
-          # Key will only be added to the partition list if it isn't already installed
-          Utils.import(keys.last, params[:keychain_name], password: params[:keychain_password])
+            # Import the private key
+            # there seems to be no good way to check if it's already installed - so just install it
+            # Key will only be added to the partition list if it isn't already installed
+            Utils.import(keys.last, params[:keychain_name], password: params[:keychain_password])
+          end
         else
           UI.message("Skipping installation of certificate as it would not work on this operating system.")
         end
@@ -244,13 +243,14 @@ module Match
       force = params[:force]
 
       if params[:force_for_new_devices] && !params[:readonly]
-        if prov_type != :appstore && !params[:force]
+        prov_types_without_devices = [:appstore, :developer_id]
+        if !prov_types_without_devices.include?(prov_type) && !params[:force]
           force = device_count_different?(profile: profile, keychain_path: keychain_path, platform: params[:platform].to_sym)
         else
           # App Store provisioning profiles don't contain device identifiers and
           # thus shouldn't be renewed if the device count has changed.
-          UI.important("Warning: `force_for_new_devices` is set but is ignored for App Store provisioning profiles.")
-          UI.important("You can safely stop specifying `force_for_new_devices` when running Match for type 'appstore'.")
+          UI.important("Warning: `force_for_new_devices` is set but is ignored for App Store & Developer ID provisioning profiles.")
+          UI.important("You can safely stop specifying `force_for_new_devices` when running Match for type 'appstore' or 'developer_id'.")
         end
       end
 
@@ -344,7 +344,7 @@ module Match
             [
               Spaceship::ConnectAPI::Device::DeviceClass::APPLE_TV
             ]
-          when :mac, :catalyst
+          when :macos, :catalyst
             [
               Spaceship::ConnectAPI::Device::DeviceClass::MAC
             ]

data/match/lib/match/spaceship_ensure.rb

@@ -13,6 +13,9 @@ module Match
         UI.message("Creating authorization token for App Store Connect API")
         Spaceship::ConnectAPI.token = api_token
         self.team_id = team_id
+      elsif !Spaceship::ConnectAPI.token.nil?
+        UI.message("Using existing authorization token for App Store Connect API")
+        self.team_id = team_id
       else
         # We'll try to manually fetch the password
         # to tell the user that a password is optional

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

@@ -123,8 +123,8 @@ module Match
       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
+        api_token = Spaceship::ConnectAPI::Token.from(hash: self.api_key, filepath: self.api_key_path)
+        api_token ||= Spaceship::ConnectAPI.token
         return api_token
       end
 

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

@@ -196,8 +196,8 @@ module Match
       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
+        api_token = Spaceship::ConnectAPI::Token.from(hash: self.api_key, filepath: self.api_key_path)
+        api_token ||= Spaceship::ConnectAPI.token
         return api_token
       end
     end

data/pem/lib/pem/commands_generator.rb

@@ -2,6 +2,7 @@ require 'commander'
 
 require 'fastlane/version'
 require 'fastlane_core/configuration/configuration'
+require 'fastlane_core/ui/help_formatter'
 require_relative 'options'
 require_relative 'manager'
 
@@ -22,7 +23,7 @@ module PEM
       program :help, 'Author', 'Felix Krause <pem@krausefx.com>'
       program :help, 'Website', 'https://fastlane.tools'
       program :help, 'Documentation', 'https://docs.fastlane.tools/actions/pem/'
-      program :help_formatter, :compact
+      program :help_formatter, FastlaneCore::HelpFormatter
 
       global_option('--verbose') { FastlaneCore::Globals.verbose = true }
       global_option('--env STRING[,STRING2]', String, 'Add environment(s) to use with `dotenv`')

data/pilot/lib/pilot/build_manager.rb

@@ -16,7 +16,7 @@ module Pilot
       should_login_in_start = options[:apple_id].nil?
       start(options, should_login: should_login_in_start)
 
-      UI.user_error!("No ipa file given") unless config[:ipa]
+      UI.user_error!("No ipa or pkg file given") if config[:ipa].nil? && config[:pkg].nil?
 
       check_for_changelog_or_whats_new!(options)
 
@@ -25,16 +25,24 @@ module Pilot
       dir = Dir.mktmpdir
 
       platform = fetch_app_platform
-      package_path = FastlaneCore::IpaUploadPackageBuilder.new.generate(app_id: fetch_app_id,
+      if options[:ipa]
+        package_path = FastlaneCore::IpaUploadPackageBuilder.new.generate(app_id: fetch_app_id,
                                                                       ipa_path: options[:ipa],
                                                                   package_path: dir,
                                                                       platform: platform)
+      else
+        package_path = FastlaneCore::PkgUploadPackageBuilder.new.generate(app_id: fetch_app_id,
+                                                                        pkg_path: options[:pkg],
+                                                                    package_path: dir,
+                                                                        platform: platform)
+      end
 
       transporter = transporter_for_selected_team(options)
-      result = transporter.upload(fetch_app_id, package_path)
+      result = transporter.upload(package_path: package_path)
 
       unless result
-        UI.user_error!("Error uploading ipa file, for more information see above")
+        transporter_errors = transporter.displayable_errors
+        UI.user_error!("Error uploading ipa file: \n #{transporter_errors}")
       end
 
       UI.success("Successfully uploaded the new binary to App Store Connect")
@@ -90,8 +98,16 @@ module Pilot
 
     def wait_for_build_processing_to_be_complete(return_when_build_appears = false)
       platform = fetch_app_platform
-      app_version = FastlaneCore::IpaFileAnalyser.fetch_app_version(config[:ipa])
-      app_build = FastlaneCore::IpaFileAnalyser.fetch_app_build(config[:ipa])
+      if config[:ipa]
+        app_version = FastlaneCore::IpaFileAnalyser.fetch_app_version(config[:ipa])
+        app_build = FastlaneCore::IpaFileAnalyser.fetch_app_build(config[:ipa])
+      elsif config[:pkg]
+        app_version = FastlaneCore::PkgFileAnalyser.fetch_app_version(config[:pkg])
+        app_build = FastlaneCore::PkgFileAnalyser.fetch_app_build(config[:pkg])
+      else
+        app_version = config[:app_version]
+        app_build = config[:build_number]
+      end
 
       latest_build = FastlaneCore::BuildWatcher.wait_for_build_processing_to_be_complete(
         app_id: app.id,
@@ -99,8 +115,11 @@ module Pilot
         app_version: app_version,
         build_version: app_build,
         poll_interval: config[:wait_processing_interval],
+        timeout_duration: config[:wait_processing_timeout_duration],
         return_when_build_appears: return_when_build_appears,
-        return_spaceship_testflight_build: false
+        return_spaceship_testflight_build: false,
+        select_latest: config[:distribute_only],
+        wait_for_build_beta_detail_processing: true
       )
 
       unless latest_build.app_version == app_version && latest_build.version == app_build
@@ -248,9 +267,13 @@ module Pilot
         end
       end
 
-      update_build_beta_details(build, {
-        auto_notify_enabled: options[:notify_external_testers]
-      })
+      if options[:notify_external_testers].nil?
+        UI.important("Using App Store Connect's default for notifying external testers (which is true) - set `notify_external_testers` for full control")
+      else
+        update_build_beta_details(build, {
+          auto_notify_enabled: options[:notify_external_testers]
+        })
+      end
     end
 
     def self.truncate_changelog(changelog)
@@ -355,6 +378,7 @@ module Pilot
     # If there are fewer than two teams, don't infer the provider.
     def transporter_for_selected_team(options)
       # Use JWT auth
+      api_token = Spaceship::ConnectAPI.token
       unless api_token.nil?
         api_token.refresh! if api_token.expired?
         return FastlaneCore::ItunesTransporter.new(nil, nil, false, nil, api_token.text)
@@ -423,14 +447,21 @@ module Pilot
 
         UI.important("Export compliance has been set to '#{uses_non_exempt_encryption}'. Need to wait for build to finishing processing again...")
         UI.important("Set 'ITSAppUsesNonExemptEncryption' in the 'Info.plist' to skip this step and speed up the submission")
-        return wait_for_build_processing_to_be_complete
+
+        loop do
+          build = Spaceship::ConnectAPI::Build.get(build_id: uploaded_build.id)
+          return build unless build.missing_export_compliance?
+
+          UI.message("Waiting for build #{uploaded_build.id} to process export compliance")
+          sleep(5)
+        end
       else
         return uploaded_build
       end
     end
 
     def update_review_detail(build, info)
-      info = info.collect { |k, v| [k.to_sym, v] }.to_h
+      info = info.transform_keys(&:to_sym)
 
       attributes = {}
       attributes[:contactEmail] = info[:contact_email] if info.key?(:contact_email)
@@ -446,7 +477,7 @@ module Pilot
     end
 
     def update_localized_app_review(build, info_by_lang, default_info: nil)
-      info_by_lang = info_by_lang.collect { |k, v| [k.to_sym, v] }.to_h
+      info_by_lang = info_by_lang.transform_keys(&:to_sym)
 
       if default_info
         info_by_lang.delete(:default)
@@ -492,7 +523,7 @@ module Pilot
     end
 
     def update_localized_build_review(build, info_by_lang, default_info: nil)
-      info_by_lang = info_by_lang.collect { |k, v| [k.to_sym, v] }.to_h
+      info_by_lang = info_by_lang.transform_keys(&:to_sym)
 
       if default_info
         info_by_lang.delete(:default)
@@ -538,7 +569,6 @@ module Pilot
       attributes[:autoNotifyEnabled] = info[:auto_notify_enabled] if info.key?(:auto_notify_enabled)
       build_beta_detail = build.build_beta_detail
 
-      # https://github.com/fastlane/fastlane/pull/16006
       if build_beta_detail
         Spaceship::ConnectAPI.patch_build_beta_details(build_beta_details_id: build_beta_detail.id, attributes: attributes)
       else

data/pilot/lib/pilot/commands_generator.rb

@@ -1,6 +1,7 @@
 require "commander"
 
 require 'fastlane_core/configuration/configuration'
+require 'fastlane_core/ui/help_formatter'
 require_relative 'module'
 require_relative 'tester_importer'
 require_relative 'tester_exporter'
@@ -51,7 +52,7 @@ module Pilot
       program :help, "Author", "Felix Krause <pilot@krausefx.com>"
       program :help, "Website", "https://fastlane.tools"
       program :help, "Documentation", "https://docs.fastlane.tools/actions/pilot/"
-      program :help_formatter, :compact
+      program :help_formatter, FastlaneCore::HelpFormatter
 
       global_option("--verbose") { FastlaneCore::Globals.verbose = true }
 

data/pilot/lib/pilot/manager.rb

@@ -13,28 +13,31 @@ module Pilot
     def start(options, should_login: true)
       return if @config # to not login multiple times
       @config = options
-      login if should_login
+
+      # we will always start with App Store Connect API login 'if possible'
+      # else fallback to 'should_login' param for 'apple_id' login
+      login if options[:api_key_path] || options[:api_key] || should_login
     end
 
     def login
-      if api_token
+      if (api_token = Spaceship::ConnectAPI::Token.from(hash: config[:api_key], filepath: config[:api_key_path]))
         UI.message("Creating authorization token for App Store Connect API")
         Spaceship::ConnectAPI.token = api_token
+      elsif !Spaceship::ConnectAPI.token.nil?
+        UI.message("Using existing authorization token for App Store Connect API")
       else
         config[:username] ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
 
+        # Username is now optional since addition of App Store Connect API Key
+        # Force asking for username to prompt user if not already set
+        config.fetch(:username, force_ask: true)
+
         UI.message("Login to App Store Connect (#{config[:username]})")
         Spaceship::ConnectAPI.login(config[:username], use_portal: false, use_tunes: true, tunes_team_id: config[:team_id], team_name: config[:team_name])
         UI.message("Login successful")
       end
     end
 
-    def api_token
-      @api_token ||= Spaceship::ConnectAPI::Token.create(config[:api_key]) if config[:api_key]
-      @api_token ||= Spaceship::ConnectAPI::Token.from_json_file(config[:api_key_path]) if config[:api_key_path]
-      return @api_token
-    end
-
     # The app object we're currently using
     def app
       @app_id ||= fetch_app_id
@@ -70,7 +73,8 @@ module Pilot
 
     def fetch_app_identifier
       result = config[:app_identifier]
-      result ||= FastlaneCore::IpaFileAnalyser.fetch_app_identifier(config[:ipa])
+      result ||= FastlaneCore::IpaFileAnalyser.fetch_app_identifier(config[:ipa]) if config[:ipa]
+      result ||= FastlaneCore::PkgFileAnalyser.fetch_app_identifier(config[:pkg]) if config[:pkg]
       result ||= UI.input("Please enter the app's bundle identifier: ")
       UI.verbose("App identifier (#{result})")
       return result
@@ -79,6 +83,7 @@ module Pilot
     def fetch_app_platform(required: true)
       result = config[:app_platform]
       result ||= FastlaneCore::IpaFileAnalyser.fetch_app_platform(config[:ipa]) if config[:ipa]
+      result ||= FastlaneCore::PkgFileAnalyser.fetch_app_platform(config[:pkg]) if config[:pkg]
       if required
         result ||= UI.input("Please enter the app's platform (appletvos, ios, osx): ")
         UI.user_error!("App Platform must be ios, appletvos, or osx") unless ['ios', 'appletvos', 'osx'].include?(result)