fastlane 2.173.0 → 2.194.0

data/fastlane_core/lib/fastlane_core/build_watcher.rb

@@ -3,10 +3,15 @@ require 'spaceship/connect_api'
 require_relative 'ui/ui'
 
 module FastlaneCore
+  class BuildWatcherError < StandardError
+  end
+
   class BuildWatcher
+    VersionMatches = Struct.new(:version, :builds)
+
     class << self
       # @return The build we waited for. This method will always return a build
-      def wait_for_build_processing_to_be_complete(app_id: nil, platform: nil, train_version: nil, app_version: nil, build_version: nil, poll_interval: 10, strict_build_watch: false, return_when_build_appears: false, return_spaceship_testflight_build: true, select_latest: false)
+      def wait_for_build_processing_to_be_complete(app_id: nil, platform: nil, train_version: nil, app_version: nil, build_version: nil, poll_interval: 10, timeout_duration: nil, strict_build_watch: false, return_when_build_appears: false, return_spaceship_testflight_build: true, select_latest: false, wait_for_build_beta_detail_processing: false)
         # Warn about train_version being removed in the future
         if train_version
           UI.deprecated(":train_version is no longer a used argument on FastlaneCore::BuildWatcher. Please use :app_version instead.")
@@ -21,22 +26,35 @@ module FastlaneCore
         platform = Spaceship::ConnectAPI::Platform.map(platform) if platform
         UI.message("Waiting for processing on... app_id: #{app_id}, app_version: #{app_version}, build_version: #{build_version}, platform: #{platform}")
 
+        build_watching_start_time = Time.new
+        unless timeout_duration.nil?
+          end_time = build_watching_start_time + timeout_duration
+          UI.message("Will timeout watching build after #{timeout_duration} seconds around #{end_time}...")
+        end
+
         showed_info = false
         loop do
-          matched_build = matching_build(watched_app_version: app_version, watched_build_version: build_version, app_id: app_id, platform: platform, select_latest: select_latest)
+          matched_build, app_version_queried = matching_build(watched_app_version: app_version, watched_build_version: build_version, app_id: app_id, platform: platform, select_latest: select_latest)
 
           if matched_build.nil? && !showed_info
             UI.important("Read more information on why this build isn't showing up yet - https://github.com/fastlane/fastlane/issues/14997")
             showed_info = true
           end
 
-          report_status(build: matched_build)
+          report_status(build: matched_build, wait_for_build_beta_detail_processing: wait_for_build_beta_detail_processing)
 
           # Processing of builds by AppStoreConnect can be a very time consuming task and will
           # block the worker running this task until it is completed. In some cases,
           # having a build resource appear in AppStoreConnect (matched_build) may be enough (i.e. setting a changelog)
           # so here we may choose to skip the full processing of the build if return_when_build_appears is true
-          if matched_build && (return_when_build_appears || matched_build.processed?)
+          if matched_build && (return_when_build_appears || processed?(build: matched_build, wait_for_build_beta_detail_processing: wait_for_build_beta_detail_processing))
+
+            if !app_version.nil? && app_version != app_version_queried
+              UI.important("App version is #{app_version} but build was found while querying #{app_version_queried}")
+              UI.important("This shouldn't be an issue as Apple sees #{app_version} and #{app_version_queried} as equal")
+              UI.important("See docs for more info - https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/20001431-102364")
+            end
+
             if return_spaceship_testflight_build
               return matched_build.to_testflight_build
             else
@@ -44,6 +62,9 @@ module FastlaneCore
             end
           end
 
+          # Before next poll, force stop build watching, if we exceeded the 'timeout_duration' waiting time
+          force_stop_build_watching_if_required(start_time: build_watching_start_time, timeout_duration: timeout_duration)
+
           sleep(poll_interval)
         end
       end
@@ -60,37 +81,112 @@ module FastlaneCore
         watched_app_version = remove_version_leading_zeros(version: watched_app_version)
         watched_build_version = remove_version_leading_zeros(version: watched_build_version)
 
-        matched_builds = Spaceship::ConnectAPI::Build.all(
-          app_id: app_id,
-          version: watched_app_version,
-          build_number: watched_build_version,
-          platform: platform
-        )
+        # App Store Connect will allow users to upload  X.Y is the same as X.Y.0 and treat them as the same version
+        # However, only the first uploaded version format will be the one that is queryable
+        # This could lead to BuildWatcher never finding X.Y.0 if X.Y was upoaded first as X.Y will only yield results
+        #
+        # This will add an additional request to search for both X.Y and X.Y.0 but
+        # will give preference to the version format specified passed in
+        watched_app_version_alternate = alternate_version(watched_app_version)
+        versions = [watched_app_version, watched_app_version_alternate].compact
+
+        if versions.empty?
+          if select_latest
+            message = watched_build_version.nil? ? "Searching for the latest build" : "Searching for the latest build with build number: #{watched_build_version}"
+            UI.message(message)
+            versions = [nil]
+          else
+            raise BuildWatcherError.new, "There is no app version to watch"
+          end
+        end
+
+        version_matches = versions.map do |version|
+          match = VersionMatches.new
+          match.version = version
+          match.builds = Spaceship::ConnectAPI::Build.all(
+            app_id: app_id,
+            version: version,
+            build_number: watched_build_version,
+            platform: platform
+          )
+
+          match
+        end.flatten
 
         # Raise error if more than 1 build is returned
         # This should never happen but need to inform the user if it does
+        matched_builds = version_matches.map(&:builds).flatten
         if matched_builds.size > 1 && !select_latest
           error_builds = matched_builds.map do |build|
             "#{build.app_version}(#{build.version}) for #{build.platform} - #{build.processing_state}"
           end.join("\n")
-          error_message = "FastlaneCore::BuildWatcher found more than 1 matching build: \n#{error_builds}"
-          UI.crash!(error_message)
+          error_message = "Found more than 1 matching build: \n#{error_builds}"
+          raise BuildWatcherError.new, error_message
         end
 
-        matched_build = matched_builds.first
+        version_match = version_matches.reject do |match|
+          match.builds.empty?
+        end.first
+        matched_build = version_match&.builds&.first
 
-        return matched_build
+        return matched_build, version_match&.version
       end
 
-      def report_status(build: nil)
-        if build && !build.processed?
+      def alternate_version(version)
+        return nil if version.nil?
+
+        version_info = Gem::Version.new(version)
+        if version_info.segments.size == 3 && version_info.segments[2] == 0
+          return version_info.segments[0..1].join(".")
+        elsif version_info.segments.size == 2
+          return "#{version}.0"
+        end
+
+        return nil
+      end
+
+      def processed?(build: nil, wait_for_build_beta_detail_processing: false)
+        return false unless build
+
+        is_processed = build.processed?
+
+        # App Store Connect API has multiple build processing states
+        # builds have one processing status
+        # buildBetaDetails have two processing statues (internal and external testing)
+        #
+        # If set, this method will only return true if all three statuses are complete
+        if wait_for_build_beta_detail_processing
+          is_processed &&= (build.build_beta_detail&.processed? || false)
+        end
+
+        return is_processed
+      end
+
+      def report_status(build: nil, wait_for_build_beta_detail_processing: false)
+        is_processed = processed?(build: build, wait_for_build_beta_detail_processing: wait_for_build_beta_detail_processing)
+
+        if build && !is_processed
           UI.message("Waiting for App Store Connect to finish processing the new build (#{build.app_version} - #{build.version}) for #{build.platform}")
-        elsif build && build.processed?
+        elsif build && is_processed
           UI.success("Successfully finished processing the build #{build.app_version} - #{build.version} for #{build.platform}")
         else
           UI.message("Waiting for the build to show up in the build list - this may take a few minutes (check your email for processing issues if this continues)")
         end
       end
+
+      def force_stop_build_watching_if_required(start_time: nil, timeout_duration: nil)
+        return if start_time.nil? || timeout_duration.nil? # keep watching build for App Store Connect processing
+
+        current_time = Time.new
+        end_time = start_time + timeout_duration
+        pending_duration = end_time - current_time
+
+        if current_time > end_time
+          UI.crash!("FastlaneCore::BuildWatcher exceeded the '#{timeout_duration.to_i}' seconds, Stopping now!")
+        else
+          UI.verbose("Will timeout watching build after pending #{pending_duration.to_i} seconds around #{end_time}...")
+        end
+      end
     end
   end
 end

data/fastlane_core/lib/fastlane_core/clipboard.rb

@@ -0,0 +1,20 @@
+require 'fastlane_core'
+require 'open3'
+
+module FastlaneCore
+  class Clipboard
+    def self.copy(content: nil)
+      return UI.crash!("'pbcopy' or 'pbpaste' command not found.") unless is_supported?
+      Open3.popen3('pbcopy') { |input, _, _| input << content }
+    end
+
+    def self.paste
+      return UI.crash!("'pbcopy' or 'pbpaste' command not found.") unless is_supported?
+      return `pbpaste`
+    end
+
+    def self.is_supported?
+      return `which pbcopy`.length > 0 && `which pbpaste`.length > 0
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/command_executor.rb

@@ -13,16 +13,10 @@ module FastlaneCore
       #
       # Derived from https://stackoverflow.com/a/5471032/3005
       def which(cmd)
-        # PATHEXT contains the list of file extensions that Windows considers executable, semicolon separated.
-        # e.g. ".COM;.EXE;.BAT;.CMD"
-        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : []
-        exts << '' # Always have an empty string (= no file extension)
-
         ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-          exts.each do |ext|
-            cmd_path = File.join(path, "#{cmd}#{ext}")
-            return cmd_path if Helper.executable?(cmd_path)
-          end
+          cmd_path = File.join(path, cmd)
+          executable_path = Helper.get_executable_path(cmd_path)
+          return executable_path if Helper.executable?(executable_path)
         end
 
         return nil

data/fastlane_core/lib/fastlane_core/configuration/commander_generator.rb

@@ -30,6 +30,11 @@ module FastlaneCore
           type = option.is_string ? String : nil
         end
 
+        # OptionParser doesn't like symbol but a symbol and string can be easily cast with `to_sym` and `to_s`
+        if type == Symbol
+          type = String
+        end
+
         # Boolean is a fastlane thing, it's either TrueClass, or FalseClass, but we won't know
         # that until runtime, so nil is the best we get
         if type == Fastlane::Boolean
@@ -67,7 +72,7 @@ module FastlaneCore
         long_switch = "--#{option.key} #{value_appendix}"
 
         description = option.description
-        description += " (#{option.env_name})" unless option.env_name.to_s.empty?
+        description += " (#{option.env_names.join(', ')})" unless option.env_names.empty?
 
         # We compact this array here to remove the short_switch variable if it is nil.
         # Passing a nil value to global_option has been shown to create problems with

data/fastlane_core/lib/fastlane_core/configuration/config_item.rb

@@ -12,6 +12,9 @@ module FastlaneCore
     # [String] the name of the environment variable, which is only used if no other values were found
     attr_accessor :env_name
 
+    # [Array] the names of the environment variables, which is only used if no other values were found
+    attr_accessor :env_names
+
     # [String] A description shown to the user
     attr_accessor :description
 
@@ -71,6 +74,7 @@ module FastlaneCore
     # Creates a new option
     # @param key (Symbol) the key which is used as command parameters or key in the fastlane tools
     # @param env_name (String) the name of the environment variable, which is only used if no other values were found
+    # @param env_names (Array) the names of the environment variables, which is only used if no other values were found
     # @param description (String) A description shown to the user
     # @param short_option (String) A string of length 1 which is used for the command parameters (e.g. -f)
     # @param default_value the value which is used if there was no given values and no environment values
@@ -88,8 +92,10 @@ module FastlaneCore
     # @param sensitive (Boolean) Set if the variable is sensitive, such as a password or API token, to prevent echoing when prompted for the parameter
     # @param display_in_shell (Boolean) Set if the variable can be used from shell
     # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable Metrics/PerceivedComplexity
     def initialize(key: nil,
                    env_name: nil,
+                   env_names: nil,
                    description: nil,
                    short_option: nil,
                    default_value: nil,
@@ -109,6 +115,11 @@ module FastlaneCore
       UI.user_error!("key must be a symbol") unless key.kind_of?(Symbol)
       UI.user_error!("env_name must be a String") unless (env_name || '').kind_of?(String)
 
+      UI.user_error!("env_names must be an Array") unless (env_names || []).kind_of?(Array)
+      (env_names || []).each do |name|
+        UI.user_error!("env_names must only contain String") unless (name || '').kind_of?(String)
+      end
+
       if short_option
         UI.user_error!("short_option for key :#{key} must of type String") unless short_option.kind_of?(String)
         UI.user_error!("short_option for key :#{key} must be a string of length 1") unless short_option.delete('-').length == 1
@@ -138,6 +149,7 @@ module FastlaneCore
 
       @key = key
       @env_name = env_name
+      @env_names = [env_name].compact + (env_names || [])
       @description = description
       @short_option = short_option
       @default_value = default_value
@@ -160,6 +172,7 @@ module FastlaneCore
 
       update_code_gen_default_value_if_able!
     end
+    # rubocop:enable Metrics/PerceivedComplexity
     # rubocop:enable Metrics/ParameterLists
 
     # if code_gen_default_value is nil, use the default value if it isn't a `code_gen_sensitive` value
@@ -203,6 +216,17 @@ module FastlaneCore
       end
     end
 
+    def ensure_array_type_passes_validation(value)
+      if @skip_type_validation
+        return
+      end
+
+      # Arrays can be an either be an array or string that gets split by comma in auto_convert_type
+      if !value.kind_of?(Array) && !value.kind_of?(String)
+        UI.user_error!("'#{self.key}' value must be either `Array` or `comma-separated String`! Found #{value.class} instead.")
+      end
+    end
+
     # Make sure, the value is valid (based on the verify block)
     # Raises an exception if the value is invalid
     def valid?(value)
@@ -212,6 +236,8 @@ module FastlaneCore
       # Verify that value is the type that we're expecting, if we are expecting a type
       if data_type == Fastlane::Boolean
         ensure_boolean_type_passes_validation(value)
+      elsif data_type == Array
+        ensure_array_type_passes_validation(value)
       else
         ensure_generic_type_passes_validation(value)
       end
@@ -228,6 +254,16 @@ module FastlaneCore
       true
     end
 
+    def fetch_env_value
+      env_names.each do |name|
+        next if ENV[name].nil?
+        # verify! before using (see https://github.com/fastlane/fastlane/issues/14449)
+        return ENV[name].dup if verify!(auto_convert_value(ENV[name]))
+      end
+
+      return nil
+    end
+
     # rubocop:disable Metrics/PerceivedComplexity
     # Returns an updated value type (if necessary)
     def auto_convert_value(value)
@@ -239,6 +275,8 @@ module FastlaneCore
         return value.to_i if value.to_i.to_s == value.to_s
       elsif data_type == Float
         return value.to_f if value.to_f.to_s == value.to_s
+      elsif data_type == Symbol
+        return value.to_sym if value.to_sym.to_s == value.to_s
       elsif allow_shell_conversion
         return value.shelljoin if value.kind_of?(Array)
         return value.map { |k, v| "#{k.to_s.shellescape}=#{v.shellescape}" }.join(' ') if value.kind_of?(Hash)
@@ -249,11 +287,11 @@ module FastlaneCore
         rescue JSON::ParserError
         end
       elsif data_type != String
-        # Special treatment if the user specified true, false or YES, NO
+        # Special treatment if the user specified true, false, on, off or YES, NO
         # There is no boolean type, so we just do it here
-        if %w(YES yes true TRUE).include?(value)
+        if %w(yes YES true TRUE on ON).include?(value)
           return true
-        elsif %w(NO no false FALSE).include?(value)
+        elsif %w(no NO false FALSE off OFF).include?(value)
           return false
         end
       end

data/fastlane_core/lib/fastlane_core/configuration/configuration.rb

@@ -208,19 +208,19 @@ module FastlaneCore
     #####################################################
 
     # Returns the value for a certain key. fastlane_core tries to fetch the value from different sources
-    # if 'ask' is true and the value is not present, the user will be prompted to provide a value
+    # if 'ask' is true and the value is not present, the user will be prompted to provide a value if optional
+    # if 'force_ask' is true, the option is not required to be optional to ask
     # rubocop:disable Metrics/PerceivedComplexity
-    def fetch(key, ask: true)
-      UI.crash!("Key '#{key}' must be a symbol. Example :app_id.") unless key.kind_of?(Symbol)
+    def fetch(key, ask: true, force_ask: false)
+      UI.crash!("Key '#{key}' must be a symbol. Example :#{key}") unless key.kind_of?(Symbol)
 
       option = verify_options_key!(key)
 
       # Same order as https://docs.fastlane.tools/advanced/#priorities-of-parameters-and-options
       value = if @values.key?(key) && !@values[key].nil?
                 @values[key]
-              elsif option.env_name && !ENV[option.env_name].nil?
-                # verify! before using (see https://github.com/fastlane/fastlane/issues/14449)
-                ENV[option.env_name].dup if option.verify!(option.auto_convert_value(ENV[option.env_name]))
+              elsif (env_value = option.fetch_env_value)
+                env_value
               elsif self.config_file_options.key?(key)
                 self.config_file_options[key]
               else
@@ -229,7 +229,7 @@ module FastlaneCore
 
       value = option.auto_convert_value(value)
       value = nil if value.nil? && !option.string? # by default boolean flags are false
-      return value unless value.nil? && !option.optional && ask
+      return value unless value.nil? && (!option.optional || force_ask) && ask
 
       # fallback to asking
       if Helper.test? || !UI.interactive?
@@ -243,11 +243,17 @@ module FastlaneCore
       while value.nil?
         UI.important("To not be asked about this value, you can specify it using '#{option.key}'") if ENV["FASTLANE_ONBOARDING_IN_PROCESS"].to_s.length == 0
         value = option.sensitive ? UI.password("#{option.description}: ") : UI.input("#{option.description}: ")
+
+        # ConfigItem allows to specify a type for the item but UI.password and
+        # UI.input return String values. Try to convert the String input to
+        # the option's type before passing it along.
+        value = option.auto_convert_value(value)
+
         # Also store this value to use it from now on
         begin
           set(key, value)
         rescue => ex
-          puts(ex)
+          UI.error(ex)
           value = nil
         end
       end

data/fastlane_core/lib/fastlane_core/device_manager.rb

@@ -118,7 +118,7 @@ module FastlaneCore
           discover_devices(child_item, device_types, discovered_device_udids)
         end
 
-        is_supported_device = device_types.any? { |device_type| usb_item['_name'] == device_type }
+        is_supported_device = device_types.any?(usb_item['_name'])
         serial_num = usb_item['serial_num'] || ''
         has_serial_number = serial_num.length == 40 || serial_num.length == 24
 

data/fastlane_core/lib/fastlane_core/helper.rb

@@ -75,7 +75,7 @@ module FastlaneCore
 
       # Check for Jenkins, Travis CI, ... environment variables
       ['JENKINS_HOME', 'JENKINS_URL', 'TRAVIS', 'CI', 'APPCENTER_BUILD_ID', 'TEAMCITY_VERSION', 'GO_PIPELINE_NAME', 'bamboo_buildKey', 'GITLAB_CI', 'XCS', 'TF_BUILD', 'GITHUB_ACTION', 'GITHUB_ACTIONS', 'BITRISE_IO', 'BUDDY'].each do |current|
-        return true if ENV.key?(current)
+        return true if FastlaneCore::Env.truthy?(current)
       end
       return false
     end
@@ -167,11 +167,23 @@ module FastlaneCore
       @xcode_version
     end
 
-    # @return true if Xcode version is higher than 8.3
+    # @return true if installed Xcode version is 'greater than or equal to' the input parameter version
     def self.xcode_at_least?(version)
-      FastlaneCore::UI.user_error!("Unable to locate Xcode. Please make sure to have Xcode installed on your machine") if xcode_version.nil?
-      v = xcode_version
-      Gem::Version.new(v) >= Gem::Version.new(version)
+      installed_xcode_version = xcode_version
+      UI.user_error!("Unable to locate Xcode. Please make sure to have Xcode installed on your machine") if installed_xcode_version.nil?
+      Gem::Version.new(installed_xcode_version) >= Gem::Version.new(version)
+    end
+
+    # Swift
+    #
+
+    # @return Swift version
+    def self.swift_version
+      if system("which swift > /dev/null 2>&1")
+        output = `swift --version`
+        return output.split("\n").first.match(/version ([0-9.]+)/).captures.first
+      end
+      return nil
     end
 
     # iTMSTransporter
@@ -368,8 +380,37 @@ module FastlaneCore
 
     # checks if a given path is an executable file
     def self.executable?(cmd_path)
-      # no executable files on Windows, so existing is enough there
-      cmd_path && !File.directory?(cmd_path) && (File.executable?(cmd_path) || (self.windows? && File.exist?(cmd_path)))
+      if !cmd_path || File.directory?(cmd_path)
+        return false
+      end
+
+      return File.exist?(get_executable_path(cmd_path))
+    end
+
+    # returns the path of the executable with the correct extension on Windows
+    def self.get_executable_path(cmd_path)
+      cmd_path = localize_file_path(cmd_path)
+
+      if self.windows?
+        # PATHEXT contains the list of file extensions that Windows considers executable, semicolon separated.
+        # e.g. ".COM;.EXE;.BAT;.CMD"
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : []
+
+        # no executable files on Windows, so existing is enough there
+        # also check if command + ext is present
+        exts.each do |ext|
+          executable_path = "#{cmd_path}#{ext.downcase}"
+          return executable_path if File.exist?(executable_path)
+        end
+      end
+
+      return cmd_path
+    end
+
+    # returns the path with the platform-specific path separator (`/` on UNIX, `\` on Windows)
+    def self.localize_file_path(path)
+      # change `/` to `\` on Windows
+      return self.windows? ? path.gsub('/', '\\') : path
     end
 
     # checks if given file is a valid json file
@@ -425,20 +466,35 @@ module FastlaneCore
       UI.current.log
     end
 
-    def self.ask_password(message: "Passphrase: ", confirm: nil)
+    def self.ask_password(message: "Passphrase: ", confirm: nil, confirmation_message: "Type passphrase again: ")
       raise "This code should only run in interactive mode" unless UI.interactive?
 
       loop do
         password = UI.password(message)
         if confirm
-          password2 = UI.password("Type passphrase again: ")
+          password2 = UI.password(confirmation_message)
           if password == password2
             return password
           end
         else
           return password
         end
-        UI.error("Passphrases differ. Try again")
+        UI.error("Your entries do not match. Please try again")
+      end
+    end
+
+    # URI.open added by `require 'open-uri'` is not available in Ruby 2.4. This helper lets you open a URI
+    # by choosing appropriate interface to do so depending on Ruby version. This helper is subject to be removed
+    # when fastlane drops Ruby 2.4 support.
+    def self.open_uri(*rest, &block)
+      require 'open-uri'
+
+      if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.5')
+        dup = rest.dup
+        uri = dup.shift
+        URI.parse(uri).open(*dup, &block)
+      else
+        URI.open(*rest, &block)
       end
     end
   end

data/fastlane_core/lib/fastlane_core/ipa_upload_package_builder.rb

@@ -1,4 +1,5 @@
 require "digest/md5"
+require 'securerandom'
 
 require_relative 'globals'
 require_relative 'ui/ui'
@@ -12,7 +13,7 @@ module FastlaneCore
     attr_accessor :package_path
 
     def generate(app_id: nil, ipa_path: nil, package_path: nil, platform: nil)
-      self.package_path = File.join(package_path, "#{app_id}.itmsp")
+      self.package_path = File.join(package_path, "#{app_id}-#{SecureRandom.uuid}.itmsp")
       FileUtils.rm_rf(self.package_path) if File.directory?(self.package_path)
       FileUtils.mkdir_p(self.package_path)
 
@@ -32,7 +33,7 @@ module FastlaneCore
       File.write(File.join(self.package_path, METADATA_FILE_NAME), xml)
       UI.success("Wrote XML data to '#{self.package_path}'") if FastlaneCore::Globals.verbose?
 
-      return package_path
+      return self.package_path
     end
 
     def unique_ipa_path(ipa_path)

data/fastlane_core/lib/fastlane_core/itunes_transporter.rb

@@ -94,6 +94,10 @@ module FastlaneCore
       return exit_status.zero?
     end
 
+    def displayable_errors
+      @errors.map { |error| "[Transporter Error Output]: #{error}" }.join("\n").gsub!(/"/, "")
+    end
+
     private
 
     def parse_line(line, hide_output)
@@ -107,7 +111,6 @@ module FastlaneCore
 
       elsif line =~ ERROR_REGEX
         @errors << $1
-        UI.error("[Transporter Error Output]: #{$1}")
 
         # Check if it's a login error
         if $1.include?("Your Apple ID or password was entered incorrectly") ||
@@ -117,9 +120,6 @@ module FastlaneCore
             CredentialsManager::AccountManager.new(user: @user).invalid_credentials
             UI.error("Please run this tool again to apply the new password")
           end
-        elsif $1.include?("Redundant Binary Upload. There already exists a binary upload with build")
-          UI.error($1)
-          UI.error("You have to change the build number of your app to upload your ipa file")
         end
 
         output_done = true
@@ -471,11 +471,13 @@ module FastlaneCore
     # Uploads the modified package back to App Store Connect
     # @param app_id [Integer] The unique App ID
     # @param dir [String] the path in which the package file is located
+    # @param package_path [String] the path to the package file (used instead of app_id and dir)
     # @return (Bool) True if everything worked fine
     # @raise [Deliver::TransporterTransferError] when something went wrong
     #   when transferring
-    def upload(app_id, dir)
-      actual_dir = File.join(dir, "#{app_id}.itmsp")
+    def upload(app_id = nil, dir = nil, package_path: nil)
+      raise "app_id and dir are required or package_path is required" if (app_id.nil? || dir.nil?) && package_path.nil?
+      actual_dir = package_path || File.join(dir, "#{app_id}.itmsp")
 
       UI.message("Going to upload updated app to App Store Connect")
       UI.success("This might take a few minutes. Please don't interrupt the script.")
@@ -490,7 +492,7 @@ module FastlaneCore
         result = @transporter_executor.execute(command, ItunesTransporter.hide_transporter_output?)
       rescue TransporterRequiresApplicationSpecificPasswordError => ex
         handle_two_step_failure(ex)
-        return upload(app_id, dir)
+        return upload(app_id, dir, package_path: package_path)
       end
 
       if result
@@ -501,7 +503,11 @@ module FastlaneCore
         handle_error(@password)
       end
 
-      result
+      return result
+    end
+
+    def displayable_errors
+      @transporter_executor.displayable_errors
     end
 
     def provider_ids