fastlane_hotfix 2.165.0

data/sigh/lib/sigh/module.rb

@@ -0,0 +1,42 @@
+require 'fastlane_core/ui/ui'
+require 'fastlane_core/helper'
+
+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
+  UI = FastlaneCore::UI
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+
+  ENV['FASTLANE_TEAM_ID'] ||= ENV["SIGH_TEAM_ID"]
+  ENV['DELIVER_USER'] ||= ENV["SIGH_USERNAME"]
+end

data/sigh/lib/sigh/options.rb

@@ -0,0 +1,187 @@
+require 'fastlane_core/configuration/configuration'
+require 'credentials_manager/appfile_config'
+require_relative 'module'
+
+module Sigh
+  class Options
+    def self.available_options
+      user = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
+      user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+
+      [
+        FastlaneCore::ConfigItem.new(key: :adhoc,
+                                     env_name: "SIGH_AD_HOC",
+                                     description: "Setting this flag will generate AdHoc profiles instead of App Store Profiles",
+                                     is_string: false,
+                                     default_value: false,
+                                     conflicting_options: [:developer_id, :development],
+                                     conflict_block: proc do |option|
+                                       UI.user_error!("You can't enable both :#{option.key} and :adhoc")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :developer_id,
+                                     env_name: "SIGH_DEVELOPER_ID",
+                                     description: "Setting this flag will generate Developer ID profiles instead of App Store Profiles",
+                                     is_string: false,
+                                     default_value: false,
+                                     conflicting_options: [:adhoc, :development],
+                                     conflict_block: proc do |option|
+                                       UI.user_error!("You can't enable both :#{option.key} and :developer_id")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :development,
+                                     env_name: "SIGH_DEVELOPMENT",
+                                     description: "Renew the development certificate instead of the production one",
+                                     is_string: false,
+                                     default_value: false,
+                                     conflicting_options: [:adhoc, :developer_id],
+                                     conflict_block: proc do |option|
+                                       UI.user_error!("You can't enable both :#{option.key} and :development")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :skip_install,
+                                     env_name: "SIGH_SKIP_INSTALL",
+                                     description: "By default, the certificate will be added to your local machine. Setting this flag will skip this action",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :force,
+                                     env_name: "SIGH_FORCE",
+                                     description: "Renew provisioning profiles regardless of its state - to automatically add all devices for ad hoc profiles",
+                                     is_string: false,
+                                     short_option: "-f",
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                     short_option: "-a",
+                                     env_name: "SIGH_APP_IDENTIFIER",
+                                     description: "The bundle identifier of your app",
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier),
+                                     default_value_dynamic: true),
+
+        # App Store Connect API
+        FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                     env_name: "SIGH_API_KEY_PATH",
+                                     description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
+                                     optional: true,
+                                     conflicting_options: [:api_key],
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :api_key,
+                                     env_name: "SIGH_API_KEY",
+                                     description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#use-return-value-and-pass-in-as-an-option)",
+                                     type: Hash,
+                                     optional: true,
+                                     sensitive: true,
+                                     conflicting_options: [:api_key_path]),
+
+        # Apple ID
+        FastlaneCore::ConfigItem.new(key: :username,
+                                     short_option: "-u",
+                                     env_name: "SIGH_USERNAME",
+                                     description: "Your Apple ID Username",
+                                     default_value: user,
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :team_id,
+                                     short_option: "-b",
+                                     env_name: "SIGH_TEAM_ID",
+                                     description: "The ID of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                     default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_ID"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :team_name,
+                                     short_option: "-l",
+                                     env_name: "SIGH_TEAM_NAME",
+                                     description: "The name of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_name),
+                                     default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_NAME"] = value.to_s
+                                     end),
+
+        # Other options
+        FastlaneCore::ConfigItem.new(key: :provisioning_name,
+                                     short_option: "-n",
+                                     env_name: "SIGH_PROVISIONING_PROFILE_NAME",
+                                     description: "The name of the profile that is used on the Apple Developer Portal",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :ignore_profiles_with_different_name,
+                                     env_name: "SIGH_IGNORE_PROFILES_WITH_DIFFERENT_NAME",
+                                     description: "Use in combination with :provisioning_name - when true only profiles matching this exact name will be downloaded",
+                                     optional: true,
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :output_path,
+                                     short_option: "-o",
+                                     env_name: "SIGH_OUTPUT_PATH",
+                                     description: "Directory in which the profile should be stored",
+                                     default_value: "."),
+        FastlaneCore::ConfigItem.new(key: :cert_id,
+                                     short_option: "-i",
+                                     env_name: "SIGH_CERTIFICATE_ID",
+                                     description: "The ID of the code signing certificate to use (e.g. 78ADL6LVAA) ",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :cert_owner_name,
+                                     short_option: "-c",
+                                     env_name: "SIGH_CERTIFICATE",
+                                     description: "The certificate name to use for new profiles, or to renew with. (e.g. \"Felix Krause\")",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :filename,
+                                     short_option: "-q",
+                                     env_name: "SIGH_PROFILE_FILE_NAME",
+                                     optional: true,
+                                     description: "Filename to use for the generated provisioning profile (must include .mobileprovision)",
+                                     verify_block: proc do |value|
+                                       UI.user_error!("The output name must end with .mobileprovision") unless value.end_with?(".mobileprovision")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :skip_fetch_profiles,
+                                     env_name: "SIGH_SKIP_FETCH_PROFILES",
+                                     description: "Skips the verification of existing profiles which is useful if you have thousands of profiles",
+                                     is_string: false,
+                                     default_value: false,
+                                     short_option: "-w"),
+        FastlaneCore::ConfigItem.new(key: :skip_certificate_verification,
+                                     short_option: '-z',
+                                     env_name: "SIGH_SKIP_CERTIFICATE_VERIFICATION",
+                                     description: "Skips the verification of the certificates for every existing profiles. This will make sure the provisioning profile can be used on the local machine",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :platform,
+                                     short_option: '-p',
+                                     env_name: "SIGH_PLATFORM",
+                                     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 catalyst)
+                                       UI.user_error!("Unsupported platform, must be: #{pt}") unless pt.include?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :readonly,
+                                     env_name: "SIGH_READONLY",
+                                     description: "Only fetch existing profile, don't generate new ones",
+                                     optional: true,
+                                     is_string: false,
+                                     default_value: false,
+                                     conflicting_options: [:force],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can't enable both :force and :readonly")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :template_name,
+                                     env_name: "SIGH_PROVISIONING_PROFILE_TEMPLATE_NAME",
+                                     description: "The name of provisioning profile template. If the developer account has provisioning profile templates (aka: custom entitlements), the template name can be found by inspecting the Entitlements drop-down while creating/editing a provisioning profile (e.g. \"Apple Pay Pass Suppression Development\")",
+                                     optional: true,
+                                     default_value: nil),
+        FastlaneCore::ConfigItem.new(key: :fail_on_name_taken,
+                                     env_name: "SIGH_FAIL_ON_NAME_TAKEN",
+                                     description: "Should the command fail if it was about to create a duplicate of an existing provisioning profile. It can happen due to issues on Apple Developer Portal, when profile to be recreated was not properly deleted first",
+                                     optional: true,
+                                     is_string: false,
+                                     default_value: false)
+      ]
+    end
+  end
+end

data/sigh/lib/sigh/repair.rb

@@ -0,0 +1,34 @@
+require 'spaceship'
+
+require_relative 'module'
+
+module Sigh
+  class Repair
+    def repair_all
+      UI.message("Starting login with user '#{Sigh.config[:username]}'")
+      Spaceship.login(Sigh.config[:username], nil)
+      Spaceship.select_team
+      UI.message("Successfully logged in")
+
+      # Select all 'Invalid' or 'Expired' provisioning profiles
+      broken_profiles = Spaceship.provisioning_profile.all.find_all do |profile|
+        (profile.status == "Invalid" or profile.status == "Expired")
+      end
+
+      if broken_profiles.count == 0
+        UI.success("All provisioning profiles are valid, nothing to do")
+        return
+      end
+
+      UI.success("Going to repair #{broken_profiles.count} provisioning profiles")
+
+      # Iterate over all broken profiles and repair them
+      broken_profiles.each do |profile|
+        UI.message("Repairing profile '#{profile.name}'...")
+        profile.repair! # yes, that's all you need to repair a profile
+      end
+
+      UI.success("Successfully repaired #{broken_profiles.count} provisioning profiles")
+    end
+  end
+end

data/sigh/lib/sigh/resign.rb

@@ -0,0 +1,220 @@
+require 'shellwords'
+require 'fastlane_core/globals'
+
+require_relative 'module'
+
+module Sigh
+  # Resigns an existing ipa file
+  class Resign
+    def run(options, args)
+      # get the command line inputs and parse those into the vars we need...
+      ipa, signing_identity, provisioning_profiles, entitlements, version, display_name, short_version, bundle_version, new_bundle_id, use_app_entitlements, keychain_path = get_inputs(options, args)
+      # ... then invoke our programmatic interface with these vars
+      unless resign(ipa, signing_identity, provisioning_profiles, entitlements, version, display_name, short_version, bundle_version, new_bundle_id, use_app_entitlements, keychain_path)
+        UI.user_error!("Failed to re-sign .ipa")
+      end
+    end
+
+    def self.resign(ipa, signing_identity, provisioning_profiles, entitlements, version, display_name, short_version, bundle_version, new_bundle_id, use_app_entitlements, keychain_path)
+      self.new.resign(ipa, signing_identity, provisioning_profiles, entitlements, version, display_name, short_version, bundle_version, new_bundle_id, use_app_entitlements, keychain_path)
+    end
+
+    def resign(ipa, signing_identity, provisioning_profiles, entitlements, version, display_name, short_version, bundle_version, new_bundle_id, use_app_entitlements, keychain_path)
+      resign_path = find_resign_path
+
+      if keychain_path
+        keychain_path_absolute = File.expand_path(keychain_path)
+
+        current_keychains = `security list-keychains`
+        current_keychains.delete!("\n")
+
+        unless current_keychains.include?(keychain_path_absolute)
+          previous_keychains = current_keychains
+          `security list-keychains -s #{current_keychains} '#{keychain_path_absolute}'`
+        end
+      end
+
+      signing_identity = find_signing_identity(signing_identity)
+
+      unless provisioning_profiles.kind_of?(Enumerable)
+        provisioning_profiles = [provisioning_profiles]
+      end
+
+      # validate that we have valid values for all these params, we don't need to check signing_identity because `find_signing_identity` will only ever return a valid value
+      validate_params(resign_path, ipa, provisioning_profiles)
+      entitlements = "-e #{entitlements.shellescape}" if entitlements
+
+      provisioning_options = create_provisioning_options(provisioning_profiles)
+      version = "-n #{version}" if version
+      display_name = "-d #{display_name.shellescape}" if display_name
+      short_version = "--short-version #{short_version}" if short_version
+      bundle_version = "--bundle-version #{bundle_version}" if bundle_version
+      verbose = "-v" if FastlaneCore::Globals.verbose?
+      bundle_id = "-b '#{new_bundle_id}'" if new_bundle_id
+      use_app_entitlements_flag = "--use-app-entitlements" if use_app_entitlements
+      specific_keychain = "--keychain-path #{keychain_path.shellescape}" if keychain_path
+
+      command = [
+        resign_path.shellescape,
+        ipa.shellescape,
+        signing_identity.shellescape,
+        provisioning_options, # we are aleady shellescaping this above, when we create the provisioning_options from the provisioning_profiles
+        entitlements,
+        version,
+        display_name,
+        short_version,
+        bundle_version,
+        use_app_entitlements_flag,
+        verbose,
+        bundle_id,
+        specific_keychain,
+        ipa.shellescape # Output path must always be last argument
+      ].join(' ')
+
+      puts(command.magenta)
+      puts(`#{command}`)
+
+      if $?.to_i == 0
+        UI.success("Successfully signed #{ipa}!")
+        true
+      else
+        UI.error("Something went wrong while code signing #{ipa}")
+        false
+      end
+    ensure
+      `security list-keychains -s #{previous_keychains}` if previous_keychains
+    end
+
+    def get_inputs(options, args)
+      ipa = args.first || find_ipa || UI.input('Path to ipa file: ')
+      signing_identity = options.signing_identity || ask_for_signing_identity
+      provisioning_profiles = options.provisioning_profile || find_provisioning_profile || UI.input('Path to provisioning file: ')
+      entitlements = options.entitlements || nil
+      version = options.version_number || nil
+      display_name = options.display_name || nil
+      short_version = options.short_version || nil
+      bundle_version = options.bundle_version || nil
+      new_bundle_id = options.new_bundle_id || nil
+      use_app_entitlements = options.use_app_entitlements || nil
+      keychain_path = options.keychain_path || nil
+
+      if options.provisioning_name
+        UI.important("The provisioning_name (-n) option is not applicable to resign. You should use provisioning_profile (-p) instead")
+      end
+
+      return ipa, signing_identity, provisioning_profiles, entitlements, version, display_name, short_version, bundle_version, new_bundle_id, use_app_entitlements, keychain_path
+    end
+
+    def find_resign_path
+      File.join(Sigh::ROOT, 'lib', 'assets', 'resign.sh')
+    end
+
+    def find_ipa
+      Dir[File.join(Dir.pwd, '*.ipa')].sort { |a, b| File.mtime(a) <=> File.mtime(b) }.first
+    end
+
+    def find_provisioning_profile
+      Dir[File.join(Dir.pwd, '*.mobileprovision')].sort { |a, b| File.mtime(a) <=> File.mtime(b) }.first
+    end
+
+    def find_signing_identity(signing_identity)
+      signing_identity_input = signing_identity
+      until (signing_identity = sha1_for_signing_identity(signing_identity_input))
+        UI.error("Couldn't find signing identity '#{signing_identity_input}'.")
+        signing_identity_input = ask_for_signing_identity
+      end
+
+      signing_identity
+    end
+
+    def sha1_for_signing_identity(signing_identity)
+      identities = installed_identities
+      return signing_identity if identities.keys.include?(signing_identity)
+      identities.key(signing_identity)
+    end
+
+    def create_provisioning_options(provisioning_profiles)
+      # provisioning_profiles is passed either a hash (to be able to resign extensions/nested apps):
+      # (in that case the underlying resign.sh expects values given as "-p at.fastlane=/folder/mobile.mobileprovision -p at.fastlane.today=/folder/mobile.mobileprovision")
+      #   {
+      #     "at.fastlane" => "/folder/mobile.mobileprovision",
+      #     "at.fastlane.today" => "/folder/mobile.mobileprovision"
+      #   }
+      # or an array
+      # (resign.sh also takes "-p /folder/mobile.mobileprovision" as a param)
+      #   [
+      #        "/folder/mobile.mobileprovision"
+      #   ]
+      provisioning_profiles.map do |app_id, app_id_prov|
+        if app_id_prov
+          app_id_prov = File.expand_path(app_id_prov)
+        else
+          app_id = File.expand_path(app_id)
+        end
+        "-p #{[app_id, app_id_prov].compact.map(&:shellescape).join('=')}"
+      end.join(' ')
+    end
+
+    def validate_params(resign_path, ipa, provisioning_profiles)
+      validate_resign_path(resign_path)
+      validate_ipa_file(ipa)
+      provisioning_profiles.each { |fst, snd| validate_provisioning_file(snd || fst) }
+    end
+
+    def validate_resign_path(resign_path)
+      UI.user_error!('Could not find resign.sh file. Please try re-installing the gem') unless File.exist?(resign_path)
+    end
+
+    def validate_ipa_file(ipa)
+      UI.user_error!("ipa file could not be found or is not an ipa file (#{ipa})") unless File.exist?(ipa) && ipa.end_with?('.ipa')
+    end
+
+    def validate_provisioning_file(provisioning_profile)
+      unless File.exist?(provisioning_profile) && provisioning_profile.end_with?('.mobileprovision')
+        UI.user_error!("Provisioning profile file could not be found or is not a .mobileprovision file (#{provisioning_profile})")
+      end
+    end
+
+    def print_available_identities
+      UI.message("Available identities: \n\t#{installed_identity_descriptions.join("\n\t")}\n")
+    end
+
+    def ask_for_signing_identity
+      print_available_identities
+      UI.input('Signing Identity: ')
+    end
+
+    # Hash of available signing identities
+    def installed_identities
+      available = request_valid_identities
+      ids = {}
+      available.split("\n").each do |current|
+        begin
+          sha1 = current.match(/[a-zA-Z0-9]{40}/).to_s
+          name = current.match(/.*\"(.*)\"/)[1]
+          ids[sha1] = name
+        rescue
+          nil
+        end # the last line does not match
+      end
+
+      ids
+    end
+
+    def request_valid_identities
+      `security find-identity -v -p codesigning`
+    end
+
+    def installed_identity_descriptions
+      descriptions = []
+      installed_identities.group_by { |sha1, name| name }.each do |name, identities|
+        descriptions << name
+        # Show SHA-1 for homonymous identities
+        descriptions += identities.map do |sha1, _|
+          "\t#{sha1}"
+        end
+      end
+      descriptions
+    end
+  end
+end