fastlane 2.240.1 → 2.241.0

data/fastlane/swift/Fastlane.swift

@@ -3068,6 +3068,8 @@ public func chatwork(apiToken: String,
 
  This action deletes the files that get created in your repo as a result of running the _gym_ and _sigh_ commands. It doesn't delete the `fastlane/report.xml` though, this is probably more suited for the .gitignore.
 
+ From _cert_ it only deletes the `.cer` file. The private key (`<certificate id>.p12`, despite its name an unencrypted PEM key) and the `.certSigningRequest` that _cert_ writes to its `output_path` when it creates a certificate are kept: _cert_ uses that `.p12` to install the certificate on a machine that doesn't have it, and on systems other than macOS it is the only copy of the key. Keep them out of version control.
+
  Useful if you quickly want to send out a test build by dropping down to the command line and typing something like `fastlane beta`, without leaving your repo in a messy state afterwards.
  */
 public func cleanBuildArtifacts(excludePattern: OptionalConfigValue<String?> = .fastlaneDefault(nil)) {
@@ -3435,6 +3437,8 @@ public func createAppOnManagedPlayStore(jsonKey: OptionalConfigValue<String?> =
 
  - parameters:
    - username: Your Apple ID Username
+   - apiKeyPath: Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)
+   - apiKey: Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-hash-option)
    - appIdentifier: App Identifier (Bundle ID, e.g. com.krausefx.app)
    - bundleIdentifierSuffix: App Identifier Suffix (Ignored if App Identifier does not end with .*)
    - appName: App Name
@@ -3459,6 +3463,8 @@ public func createAppOnManagedPlayStore(jsonKey: OptionalConfigValue<String?> =
  For more information about _produce_, visit its documentation page: [https://docs.fastlane.tools/actions/produce/](https://docs.fastlane.tools/actions/produce/).
  */
 public func createAppOnline(username: String,
+                            apiKeyPath: OptionalConfigValue<String?> = .fastlaneDefault(nil),
+                            apiKey: OptionalConfigValue<[String: Any]?> = .fastlaneDefault(nil),
                             appIdentifier: String,
                             bundleIdentifierSuffix: OptionalConfigValue<String?> = .fastlaneDefault(nil),
                             appName: String,
@@ -3479,6 +3485,8 @@ public func createAppOnline(username: String,
                             itcTeamName: OptionalConfigValue<String?> = .fastlaneDefault(nil))
 {
     let usernameArg = RubyCommand.Argument(name: "username", value: username, type: nil)
+    let apiKeyPathArg = apiKeyPath.asRubyArgument(name: "api_key_path", type: nil)
+    let apiKeyArg = apiKey.asRubyArgument(name: "api_key", type: nil)
     let appIdentifierArg = RubyCommand.Argument(name: "app_identifier", value: appIdentifier, type: nil)
     let bundleIdentifierSuffixArg = bundleIdentifierSuffix.asRubyArgument(name: "bundle_identifier_suffix", type: nil)
     let appNameArg = RubyCommand.Argument(name: "app_name", value: appName, type: nil)
@@ -3498,6 +3506,8 @@ public func createAppOnline(username: String,
     let itcTeamIdArg = RubyCommand.Argument(name: "itc_team_id", value: itcTeamId, type: nil)
     let itcTeamNameArg = itcTeamName.asRubyArgument(name: "itc_team_name", type: nil)
     let array: [RubyCommand.Argument?] = [usernameArg,
+                                          apiKeyPathArg,
+                                          apiKeyArg,
                                           appIdentifierArg,
                                           bundleIdentifierSuffixArg,
                                           appNameArg,
@@ -5214,6 +5224,7 @@ public func getManagedPlayStorePublishingRights(jsonKey: OptionalConfigValue<Str
    - force: Renew provisioning profiles regardless of its state - to automatically add all devices for ad hoc profiles
    - includeMacInProfiles: Include Apple Silicon Mac devices in provisioning profiles for iOS/iPadOS apps
    - appIdentifier: The bundle identifier of your app
+   - offlineProfile: Enable profile with 'Offline Support' (7 day validity). Requires Apple ID login, not supported with App Store Connect API key authentication
    - apiKeyPath: Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)
    - apiKey: Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-hash-option)
    - username: Your Apple ID Username
@@ -5248,6 +5259,7 @@ public func getManagedPlayStorePublishingRights(jsonKey: OptionalConfigValue<Str
                                                       force: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                                                       includeMacInProfiles: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                                                       appIdentifier: String,
+                                                      offlineProfile: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                                                       apiKeyPath: OptionalConfigValue<String?> = .fastlaneDefault(nil),
                                                       apiKey: OptionalConfigValue<[String: Any]?> = .fastlaneDefault(nil),
                                                       username: OptionalConfigValue<String?> = .fastlaneDefault(nil),
@@ -5278,6 +5290,7 @@ public func getManagedPlayStorePublishingRights(jsonKey: OptionalConfigValue<Str
     let forceArg = force.asRubyArgument(name: "force", type: nil)
     let includeMacInProfilesArg = includeMacInProfiles.asRubyArgument(name: "include_mac_in_profiles", type: nil)
     let appIdentifierArg = RubyCommand.Argument(name: "app_identifier", value: appIdentifier, type: nil)
+    let offlineProfileArg = offlineProfile.asRubyArgument(name: "offline_profile", type: nil)
     let apiKeyPathArg = apiKeyPath.asRubyArgument(name: "api_key_path", type: nil)
     let apiKeyArg = apiKey.asRubyArgument(name: "api_key", type: nil)
     let usernameArg = username.asRubyArgument(name: "username", type: nil)
@@ -5307,6 +5320,7 @@ public func getManagedPlayStorePublishingRights(jsonKey: OptionalConfigValue<Str
                                           forceArg,
                                           includeMacInProfilesArg,
                                           appIdentifierArg,
+                                          offlineProfileArg,
                                           apiKeyPathArg,
                                           apiKeyArg,
                                           usernameArg,
@@ -6923,8 +6937,8 @@ public func makeChangelogFromJenkins(fallbackChangelog: String = "",
    - gitUserEmail: git user email to commit
    - shallowClone: Make a shallow clone of the repository (truncate the history to 1 revision)
    - cloneBranchDirectly: Clone just the branch specified, instead of the whole repo. This requires that the branch already exists. Otherwise the command will fail
-   - gitBasicAuthorization: Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64
-   - gitBearerAuthorization: Use a bearer authorization header to access the git repo (e.g.: access to an Azure DevOps repository), usually a string in Base64
+   - gitBasicAuthorization: Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64. Needs git 2.31 or later
+   - gitBearerAuthorization: Use a bearer authorization header to access the git repo (e.g.: access to an Azure DevOps repository), usually a string in Base64. Needs git 2.31 or later
    - gitPrivateKey: Use a private key to access the git repo (e.g.: access to GitHub repository via Deploy keys), usually a id_rsa named file or the contents hereof
    - googleCloudBucketName: Name of the Google Cloud Storage bucket to use
    - googleCloudKeysFile: Path to the gc_keys.json file
@@ -6962,6 +6976,7 @@ public func makeChangelogFromJenkins(fallbackChangelog: String = "",
    - outputPath: Path in which to export certificates, key and profile
    - skipSetPartitionList: Skips setting the partition list (which can sometimes take a long time). Setting the partition list is usually needed to prevent Xcode from prompting to allow a cert to be used for signing
    - forceLegacyEncryption: Force encryption to use legacy cbc algorithm for backwards compatibility with older match versions
+   - offlineProfile: Enable profile with 'Offline Support' (7 day validity). Requires Apple ID login, not supported with App Store Connect API key authentication
    - verbose: Print out extra information and all commands
 
  More information: https://docs.fastlane.tools/actions/match/
@@ -7023,6 +7038,7 @@ public func match(type: String = matchfile.type,
                   outputPath: OptionalConfigValue<String?> = .fastlaneDefault(matchfile.outputPath),
                   skipSetPartitionList: OptionalConfigValue<Bool> = .fastlaneDefault(matchfile.skipSetPartitionList),
                   forceLegacyEncryption: OptionalConfigValue<Bool> = .fastlaneDefault(matchfile.forceLegacyEncryption),
+                  offlineProfile: OptionalConfigValue<Bool> = .fastlaneDefault(matchfile.offlineProfile),
                   verbose: OptionalConfigValue<Bool> = .fastlaneDefault(matchfile.verbose))
 {
     let typeArg = RubyCommand.Argument(name: "type", value: type, type: nil)
@@ -7082,6 +7098,7 @@ public func match(type: String = matchfile.type,
     let outputPathArg = outputPath.asRubyArgument(name: "output_path", type: nil)
     let skipSetPartitionListArg = skipSetPartitionList.asRubyArgument(name: "skip_set_partition_list", type: nil)
     let forceLegacyEncryptionArg = forceLegacyEncryption.asRubyArgument(name: "force_legacy_encryption", type: nil)
+    let offlineProfileArg = offlineProfile.asRubyArgument(name: "offline_profile", type: nil)
     let verboseArg = verbose.asRubyArgument(name: "verbose", type: nil)
     let array: [RubyCommand.Argument?] = [typeArg,
                                           additionalCertTypesArg,
@@ -7140,6 +7157,7 @@ public func match(type: String = matchfile.type,
                                           outputPathArg,
                                           skipSetPartitionListArg,
                                           forceLegacyEncryptionArg,
+                                          offlineProfileArg,
                                           verboseArg]
     let args: [RubyCommand.Argument] = array
         .filter { $0?.value != nil }
@@ -7170,8 +7188,8 @@ public func match(type: String = matchfile.type,
    - gitUserEmail: git user email to commit
    - shallowClone: Make a shallow clone of the repository (truncate the history to 1 revision)
    - cloneBranchDirectly: Clone just the branch specified, instead of the whole repo. This requires that the branch already exists. Otherwise the command will fail
-   - gitBasicAuthorization: Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64
-   - gitBearerAuthorization: Use a bearer authorization header to access the git repo (e.g.: access to an Azure DevOps repository), usually a string in Base64
+   - gitBasicAuthorization: Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64. Needs git 2.31 or later
+   - gitBearerAuthorization: Use a bearer authorization header to access the git repo (e.g.: access to an Azure DevOps repository), usually a string in Base64. Needs git 2.31 or later
    - gitPrivateKey: Use a private key to access the git repo (e.g.: access to GitHub repository via Deploy keys), usually a id_rsa named file or the contents hereof
    - googleCloudBucketName: Name of the Google Cloud Storage bucket to use
    - googleCloudKeysFile: Path to the gc_keys.json file
@@ -7209,6 +7227,7 @@ public func match(type: String = matchfile.type,
    - outputPath: Path in which to export certificates, key and profile
    - skipSetPartitionList: Skips setting the partition list (which can sometimes take a long time). Setting the partition list is usually needed to prevent Xcode from prompting to allow a cert to be used for signing
    - forceLegacyEncryption: Force encryption to use legacy cbc algorithm for backwards compatibility with older match versions
+   - offlineProfile: Enable profile with 'Offline Support' (7 day validity). Requires Apple ID login, not supported with App Store Connect API key authentication
    - verbose: Print out extra information and all commands
 
  Use the match_nuke action to revoke your certificates and provisioning profiles.
@@ -7274,6 +7293,7 @@ public func matchNuke(type: String = "development",
                       outputPath: OptionalConfigValue<String?> = .fastlaneDefault(nil),
                       skipSetPartitionList: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                       forceLegacyEncryption: OptionalConfigValue<Bool> = .fastlaneDefault(false),
+                      offlineProfile: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                       verbose: OptionalConfigValue<Bool> = .fastlaneDefault(false))
 {
     let typeArg = RubyCommand.Argument(name: "type", value: type, type: nil)
@@ -7333,6 +7353,7 @@ public func matchNuke(type: String = "development",
     let outputPathArg = outputPath.asRubyArgument(name: "output_path", type: nil)
     let skipSetPartitionListArg = skipSetPartitionList.asRubyArgument(name: "skip_set_partition_list", type: nil)
     let forceLegacyEncryptionArg = forceLegacyEncryption.asRubyArgument(name: "force_legacy_encryption", type: nil)
+    let offlineProfileArg = offlineProfile.asRubyArgument(name: "offline_profile", type: nil)
     let verboseArg = verbose.asRubyArgument(name: "verbose", type: nil)
     let array: [RubyCommand.Argument?] = [typeArg,
                                           additionalCertTypesArg,
@@ -7391,6 +7412,7 @@ public func matchNuke(type: String = "development",
                                           outputPathArg,
                                           skipSetPartitionListArg,
                                           forceLegacyEncryptionArg,
+                                          offlineProfileArg,
                                           verboseArg]
     let args: [RubyCommand.Argument] = array
         .filter { $0?.value != nil }
@@ -7581,8 +7603,8 @@ public func notarize(package: String,
    - message: The message to display in the notification
    - sound: The name of a sound to play when the notification appears (names are listed in Sound Preferences)
    - activate: Bundle identifier of application to be opened when the notification is clicked
-   - appIcon: The URL of an image to display instead of the application icon (Mavericks+ only)
-   - contentImage: The URL of an image to display attached to the notification (Mavericks+ only)
+   - appIcon: **DEPRECATED!** The URL of an image to display instead of the application icon
+   - contentImage: The local path of an image to display attached to the notification (Mavericks+)
    - open: URL of the resource to be opened when the notification is clicked
    - execute: Shell command to run when the notification is clicked
  */
@@ -8415,6 +8437,8 @@ public func println(message: OptionalConfigValue<String?> = .fastlaneDefault(nil
 
  - parameters:
    - username: Your Apple ID Username
+   - apiKeyPath: Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)
+   - apiKey: Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-hash-option)
    - appIdentifier: App Identifier (Bundle ID, e.g. com.krausefx.app)
    - bundleIdentifierSuffix: App Identifier Suffix (Ignored if App Identifier does not end with .*)
    - appName: App Name
@@ -8439,6 +8463,8 @@ public func println(message: OptionalConfigValue<String?> = .fastlaneDefault(nil
  For more information about _produce_, visit its documentation page: [https://docs.fastlane.tools/actions/produce/](https://docs.fastlane.tools/actions/produce/).
  */
 public func produce(username: String,
+                    apiKeyPath: OptionalConfigValue<String?> = .fastlaneDefault(nil),
+                    apiKey: OptionalConfigValue<[String: Any]?> = .fastlaneDefault(nil),
                     appIdentifier: String,
                     bundleIdentifierSuffix: OptionalConfigValue<String?> = .fastlaneDefault(nil),
                     appName: String,
@@ -8459,6 +8485,8 @@ public func produce(username: String,
                     itcTeamName: OptionalConfigValue<String?> = .fastlaneDefault(nil))
 {
     let usernameArg = RubyCommand.Argument(name: "username", value: username, type: nil)
+    let apiKeyPathArg = apiKeyPath.asRubyArgument(name: "api_key_path", type: nil)
+    let apiKeyArg = apiKey.asRubyArgument(name: "api_key", type: nil)
     let appIdentifierArg = RubyCommand.Argument(name: "app_identifier", value: appIdentifier, type: nil)
     let bundleIdentifierSuffixArg = bundleIdentifierSuffix.asRubyArgument(name: "bundle_identifier_suffix", type: nil)
     let appNameArg = RubyCommand.Argument(name: "app_name", value: appName, type: nil)
@@ -8478,6 +8506,8 @@ public func produce(username: String,
     let itcTeamIdArg = RubyCommand.Argument(name: "itc_team_id", value: itcTeamId, type: nil)
     let itcTeamNameArg = itcTeamName.asRubyArgument(name: "itc_team_name", type: nil)
     let array: [RubyCommand.Argument?] = [usernameArg,
+                                          apiKeyPathArg,
+                                          apiKeyArg,
                                           appIdentifierArg,
                                           bundleIdentifierSuffixArg,
                                           appNameArg,
@@ -9002,6 +9032,7 @@ public func rubyVersion() {
    - codeCoverage: Should code coverage be generated? (Xcode 7 and up)
    - addressSanitizer: Should the address sanitizer be turned on?
    - threadSanitizer: Should the thread sanitizer be turned on?
+   - collectTestDiagnostics: Whether verbose and long-running diagnostics (like sysdiagnoses or log archives) are collected when testing. Valid values are: on-failure or never. If not specified, the value in the test plan is used. Equivalent to -collect-test-diagnostics (Xcode 14 and up)
    - openReport: Should the HTML report be opened when tests are completed?
    - outputDirectory: The directory in which all reports will be stored
    - outputStyle: Define how the output should look like. Valid values are: standard, basic, rspec, or raw (disables xcpretty during xcodebuild)
@@ -9090,6 +9121,7 @@ public func rubyVersion() {
                                         codeCoverage: OptionalConfigValue<Bool?> = .fastlaneDefault(nil),
                                         addressSanitizer: OptionalConfigValue<Bool?> = .fastlaneDefault(nil),
                                         threadSanitizer: OptionalConfigValue<Bool?> = .fastlaneDefault(nil),
+                                        collectTestDiagnostics: OptionalConfigValue<String?> = .fastlaneDefault(nil),
                                         openReport: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                                         outputDirectory: String = "./test_output",
                                         outputStyle: OptionalConfigValue<String?> = .fastlaneDefault(nil),
@@ -9174,6 +9206,7 @@ public func rubyVersion() {
     let codeCoverageArg = codeCoverage.asRubyArgument(name: "code_coverage", type: nil)
     let addressSanitizerArg = addressSanitizer.asRubyArgument(name: "address_sanitizer", type: nil)
     let threadSanitizerArg = threadSanitizer.asRubyArgument(name: "thread_sanitizer", type: nil)
+    let collectTestDiagnosticsArg = collectTestDiagnostics.asRubyArgument(name: "collect_test_diagnostics", type: nil)
     let openReportArg = openReport.asRubyArgument(name: "open_report", type: nil)
     let outputDirectoryArg = RubyCommand.Argument(name: "output_directory", value: outputDirectory, type: nil)
     let outputStyleArg = outputStyle.asRubyArgument(name: "output_style", type: nil)
@@ -9257,6 +9290,7 @@ public func rubyVersion() {
                                           codeCoverageArg,
                                           addressSanitizerArg,
                                           threadSanitizerArg,
+                                          collectTestDiagnosticsArg,
                                           openReportArg,
                                           outputDirectoryArg,
                                           outputStyleArg,
@@ -9453,6 +9487,7 @@ public func say(text: [String],
    - codeCoverage: Should code coverage be generated? (Xcode 7 and up)
    - addressSanitizer: Should the address sanitizer be turned on?
    - threadSanitizer: Should the thread sanitizer be turned on?
+   - collectTestDiagnostics: Whether verbose and long-running diagnostics (like sysdiagnoses or log archives) are collected when testing. Valid values are: on-failure or never. If not specified, the value in the test plan is used. Equivalent to -collect-test-diagnostics (Xcode 14 and up)
    - openReport: Should the HTML report be opened when tests are completed?
    - outputDirectory: The directory in which all reports will be stored
    - outputStyle: Define how the output should look like. Valid values are: standard, basic, rspec, or raw (disables xcpretty during xcodebuild)
@@ -9541,6 +9576,7 @@ public func say(text: [String],
                                     codeCoverage: OptionalConfigValue<Bool?> = .fastlaneDefault(scanfile.codeCoverage),
                                     addressSanitizer: OptionalConfigValue<Bool?> = .fastlaneDefault(scanfile.addressSanitizer),
                                     threadSanitizer: OptionalConfigValue<Bool?> = .fastlaneDefault(scanfile.threadSanitizer),
+                                    collectTestDiagnostics: OptionalConfigValue<String?> = .fastlaneDefault(scanfile.collectTestDiagnostics),
                                     openReport: OptionalConfigValue<Bool> = .fastlaneDefault(scanfile.openReport),
                                     outputDirectory: String = scanfile.outputDirectory,
                                     outputStyle: OptionalConfigValue<String?> = .fastlaneDefault(scanfile.outputStyle),
@@ -9625,6 +9661,7 @@ public func say(text: [String],
     let codeCoverageArg = codeCoverage.asRubyArgument(name: "code_coverage", type: nil)
     let addressSanitizerArg = addressSanitizer.asRubyArgument(name: "address_sanitizer", type: nil)
     let threadSanitizerArg = threadSanitizer.asRubyArgument(name: "thread_sanitizer", type: nil)
+    let collectTestDiagnosticsArg = collectTestDiagnostics.asRubyArgument(name: "collect_test_diagnostics", type: nil)
     let openReportArg = openReport.asRubyArgument(name: "open_report", type: nil)
     let outputDirectoryArg = RubyCommand.Argument(name: "output_directory", value: outputDirectory, type: nil)
     let outputStyleArg = outputStyle.asRubyArgument(name: "output_style", type: nil)
@@ -9708,6 +9745,7 @@ public func say(text: [String],
                                           codeCoverageArg,
                                           addressSanitizerArg,
                                           threadSanitizerArg,
+                                          collectTestDiagnosticsArg,
                                           openReportArg,
                                           outputDirectoryArg,
                                           outputStyleArg,
@@ -10311,6 +10349,7 @@ public func setupTravis(force: OptionalConfigValue<Bool> = .fastlaneDefault(fals
    - force: Renew provisioning profiles regardless of its state - to automatically add all devices for ad hoc profiles
    - includeMacInProfiles: Include Apple Silicon Mac devices in provisioning profiles for iOS/iPadOS apps
    - appIdentifier: The bundle identifier of your app
+   - offlineProfile: Enable profile with 'Offline Support' (7 day validity). Requires Apple ID login, not supported with App Store Connect API key authentication
    - apiKeyPath: Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)
    - apiKey: Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-hash-option)
    - username: Your Apple ID Username
@@ -10345,6 +10384,7 @@ public func setupTravis(force: OptionalConfigValue<Bool> = .fastlaneDefault(fals
                                     force: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                                     includeMacInProfiles: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                                     appIdentifier: String,
+                                    offlineProfile: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                                     apiKeyPath: OptionalConfigValue<String?> = .fastlaneDefault(nil),
                                     apiKey: OptionalConfigValue<[String: Any]?> = .fastlaneDefault(nil),
                                     username: OptionalConfigValue<String?> = .fastlaneDefault(nil),
@@ -10375,6 +10415,7 @@ public func setupTravis(force: OptionalConfigValue<Bool> = .fastlaneDefault(fals
     let forceArg = force.asRubyArgument(name: "force", type: nil)
     let includeMacInProfilesArg = includeMacInProfiles.asRubyArgument(name: "include_mac_in_profiles", type: nil)
     let appIdentifierArg = RubyCommand.Argument(name: "app_identifier", value: appIdentifier, type: nil)
+    let offlineProfileArg = offlineProfile.asRubyArgument(name: "offline_profile", type: nil)
     let apiKeyPathArg = apiKeyPath.asRubyArgument(name: "api_key_path", type: nil)
     let apiKeyArg = apiKey.asRubyArgument(name: "api_key", type: nil)
     let usernameArg = username.asRubyArgument(name: "username", type: nil)
@@ -10404,6 +10445,7 @@ public func setupTravis(force: OptionalConfigValue<Bool> = .fastlaneDefault(fals
                                           forceArg,
                                           includeMacInProfilesArg,
                                           appIdentifierArg,
+                                          offlineProfileArg,
                                           apiKeyPathArg,
                                           apiKeyArg,
                                           usernameArg,
@@ -11536,8 +11578,8 @@ public func swiftlint(mode: String = "lint",
    - gitUserEmail: git user email to commit
    - shallowClone: Make a shallow clone of the repository (truncate the history to 1 revision)
    - cloneBranchDirectly: Clone just the branch specified, instead of the whole repo. This requires that the branch already exists. Otherwise the command will fail
-   - gitBasicAuthorization: Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64
-   - gitBearerAuthorization: Use a bearer authorization header to access the git repo (e.g.: access to an Azure DevOps repository), usually a string in Base64
+   - gitBasicAuthorization: Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64. Needs git 2.31 or later
+   - gitBearerAuthorization: Use a bearer authorization header to access the git repo (e.g.: access to an Azure DevOps repository), usually a string in Base64. Needs git 2.31 or later
    - gitPrivateKey: Use a private key to access the git repo (e.g.: access to GitHub repository via Deploy keys), usually a id_rsa named file or the contents hereof
    - googleCloudBucketName: Name of the Google Cloud Storage bucket to use
    - googleCloudKeysFile: Path to the gc_keys.json file
@@ -11575,6 +11617,7 @@ public func swiftlint(mode: String = "lint",
    - outputPath: Path in which to export certificates, key and profile
    - skipSetPartitionList: Skips setting the partition list (which can sometimes take a long time). Setting the partition list is usually needed to prevent Xcode from prompting to allow a cert to be used for signing
    - forceLegacyEncryption: Force encryption to use legacy cbc algorithm for backwards compatibility with older match versions
+   - offlineProfile: Enable profile with 'Offline Support' (7 day validity). Requires Apple ID login, not supported with App Store Connect API key authentication
    - verbose: Print out extra information and all commands
 
  More information: https://docs.fastlane.tools/actions/match/
@@ -11636,6 +11679,7 @@ public func syncCodeSigning(type: String = "development",
                             outputPath: OptionalConfigValue<String?> = .fastlaneDefault(nil),
                             skipSetPartitionList: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                             forceLegacyEncryption: OptionalConfigValue<Bool> = .fastlaneDefault(false),
+                            offlineProfile: OptionalConfigValue<Bool> = .fastlaneDefault(false),
                             verbose: OptionalConfigValue<Bool> = .fastlaneDefault(false))
 {
     let typeArg = RubyCommand.Argument(name: "type", value: type, type: nil)
@@ -11695,6 +11739,7 @@ public func syncCodeSigning(type: String = "development",
     let outputPathArg = outputPath.asRubyArgument(name: "output_path", type: nil)
     let skipSetPartitionListArg = skipSetPartitionList.asRubyArgument(name: "skip_set_partition_list", type: nil)
     let forceLegacyEncryptionArg = forceLegacyEncryption.asRubyArgument(name: "force_legacy_encryption", type: nil)
+    let offlineProfileArg = offlineProfile.asRubyArgument(name: "offline_profile", type: nil)
     let verboseArg = verbose.asRubyArgument(name: "verbose", type: nil)
     let array: [RubyCommand.Argument?] = [typeArg,
                                           additionalCertTypesArg,
@@ -11753,6 +11798,7 @@ public func syncCodeSigning(type: String = "development",
                                           outputPathArg,
                                           skipSetPartitionListArg,
                                           forceLegacyEncryptionArg,
+                                          offlineProfileArg,
                                           verboseArg]
     let args: [RubyCommand.Argument] = array
         .filter { $0?.value != nil }
@@ -14215,4 +14261,4 @@ public let snapshotfile: Snapshotfile = .init()
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.208]
+// FastlaneRunnerAPIVersion [0.9.209]

data/fastlane/swift/Gymfile.swift

@@ -17,4 +17,4 @@ public class Gymfile: GymfileProtocol {
     // during the `init` process, and you won't see this message
 }
 
-// Generated with fastlane 2.240.1
+// Generated with fastlane 2.241.0

data/fastlane/swift/GymfileProtocol.swift

@@ -399,4 +399,4 @@ public extension GymfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.158]
+// FastlaneRunnerAPIVersion [0.9.159]

data/fastlane/swift/MainProcess.swift

@@ -9,9 +9,6 @@
 //
 
 import Foundation
-#if canImport(SwiftShell)
-    import SwiftShell
-#endif
 
 let argumentProcessor = ArgumentProcessor(args: CommandLine.arguments)
 let timeout = argumentProcessor.commandTimeout
@@ -20,9 +17,7 @@ class MainProcess {
     var doneRunningLane = false
     var thread: Thread!
     #if SWIFT_PACKAGE
-        var lastPrintDate = Date.distantFuture
-        var timeBetweenPrints = Int.min
-        var rubySocketCommand: AsyncCommand!
+        var rubySocketCommand: Process!
     #endif
 
     @objc func connectToFastlaneAndRunLane(_ fastfile: LaneFile?) {
@@ -44,24 +39,199 @@ class MainProcess {
         #endif
         thread.name = "worker thread"
         #if SWIFT_PACKAGE
-            let PATH = run("/bin/bash", "-c", "-l", "eval $(/usr/libexec/path_helper -s) ; echo $PATH").stdout
-            main.env["PATH"] = PATH
-            let path = main.run(bash: "which fastlane").stdout
-            let pids = main.run("lsof", "-t", "-i", ":\(argumentProcessor.port)").stdout.split(separator: "\n")
-            pids.forEach { main.run("kill", "-9", $0) }
-            rubySocketCommand = main.runAsync(path, "socket_server", "-c", argumentProcessor.commandTimeout, "-p", argumentProcessor.port)
-            lastPrintDate = Date()
-            rubySocketCommand.stderror.onStringOutput { print($0) }
-            rubySocketCommand.stdout.onStringOutput { stdout in
-                print(stdout)
-                self.timeBetweenPrints = Int(self.lastPrintDate.timeIntervalSinceNow)
-            }
+            killExistingSocketServerProcesses(port: argumentProcessor.port)
+            abortIfPortIsInUse(argumentProcessor.port)
+
+            rubySocketCommand = Process()
+            rubySocketCommand.launchPath = "/usr/bin/env"
+            rubySocketCommand.arguments = fastlaneLaunchArguments() + ["socket_server", "-c", String(timeout), "-p", String(argumentProcessor.port)]
+            rubySocketCommand.launch()
 
-            // swiftformat:disable:next redundantSelf
-            _ = Runner.waitWithPolling(self.timeBetweenPrints, toEventually: { $0 > 5 }, timeout: 10)
+            waitUntilSocketServerIsListening(port: argumentProcessor.port, serverProcess: rubySocketCommand)
             thread.start()
         #endif
     }
+
+    #if SWIFT_PACKAGE
+        /// Resolves how to invoke fastlane, replacing the previous login-shell
+        /// `eval $(path_helper)` + `which fastlane` lookup that broke under
+        /// rbenv / bundler / system-ruby mixes (#29238). First match wins:
+        /// 1. FASTLANE_SPM_BIN environment variable (explicit override)
+        /// 2. bundler binstub bin/fastlane next to the Gemfile
+        /// 3. Gemfile (BUNDLE_GEMFILE, or found from the working directory up, as Bundler does) -> bundle exec fastlane
+        /// 4. fastlane on PATH
+        func fastlaneLaunchArguments() -> [String] {
+            if let bin = ProcessInfo.processInfo.environment["FASTLANE_SPM_BIN"],
+               !bin.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            {
+                // The shell splits the value, so quoted paths with spaces work; our arguments
+                // pass through "$@" untouched, and exec keeps the launched process ID.
+                return ["/bin/sh", "-c", "exec \(bin) \"$@\"", "sh"]
+            }
+            guard let bundleRoot = bundleRootDirectory() else {
+                return ["fastlane"]
+            }
+            let binstub = bundleRoot + "/bin/fastlane"
+            if FileManager.default.isExecutableFile(atPath: binstub) {
+                return [binstub]
+            }
+            return ["bundle", "exec", "fastlane"]
+        }
+
+        /// The directory of the Gemfile Bundler would use: BUNDLE_GEMFILE, else the
+        /// nearest Gemfile or gems.rb from the working directory up.
+        func bundleRootDirectory() -> String? {
+            let workingDirectory = FileManager.default.currentDirectoryPath
+            if let gemfile = ProcessInfo.processInfo.environment["BUNDLE_GEMFILE"], !gemfile.isEmpty {
+                let path = gemfile.hasPrefix("/") ? gemfile : workingDirectory + "/" + gemfile
+                return (path as NSString).deletingLastPathComponent
+            }
+            var directory = workingDirectory
+            while true {
+                for name in ["Gemfile", "gems.rb"] where FileManager.default.fileExists(atPath: directory + "/" + name) {
+                    return directory
+                }
+                let parent = (directory as NSString).deletingLastPathComponent
+                if parent == directory || parent.isEmpty {
+                    return nil
+                }
+                directory = parent
+            }
+        }
+
+        /// The ruby socket server performs a single `accept` (see
+        /// fastlane/server/socket_server.rb), so probing readiness with a TCP
+        /// connection would consume that accept and shut the server down.
+        /// Poll the LISTEN state read-only via lsof instead of the previous
+        /// "stdout quiet for 5 seconds" heuristic.
+        private func waitUntilSocketServerIsListening(port: UInt32, serverProcess: Process) {
+            let deadline = Date(timeIntervalSinceNow: 30)
+            while Date() < deadline {
+                if !serverProcess.isRunning {
+                    log(message: "fastlane socket_server exited with status \(serverProcess.terminationStatus) before listening. Check that the resolved fastlane installation works (e.g. `bundle exec fastlane --version`).")
+                    exit(1)
+                }
+                if isPortListening(port, by: serverProcess.processIdentifier) {
+                    return
+                }
+                Thread.sleep(forTimeInterval: 0.2)
+            }
+            // Don't leak the socket server: it's still running (just not
+            // listening yet) on this timeout path, so terminate it before exit.
+            terminate(serverProcess: serverProcess)
+            log(message: "fastlane socket_server did not start listening on port \(port) within 30 seconds")
+            exit(1)
+        }
+
+        /// Terminate the socket server, escalating SIGTERM to SIGKILL if it
+        /// doesn't exit promptly, so the timeout path never leaves an orphan.
+        private func terminate(serverProcess: Process) {
+            serverProcess.terminate()
+            let killDeadline = Date(timeIntervalSinceNow: 2)
+            while serverProcess.isRunning, Date() < killDeadline {
+                Thread.sleep(forTimeInterval: 0.1)
+            }
+            if serverProcess.isRunning {
+                _ = outputOfProcess(arguments: ["/bin/kill", "-9", String(serverProcess.processIdentifier)])
+                serverProcess.waitUntilExit()
+            }
+        }
+
+        /// Clears a stale socket server left by a previously crashed run on this
+        /// port. Scoped to LISTENing ruby processes (`-sTCP:LISTEN -a -c ruby`)
+        /// so it never kills an unrelated service or a connected client that
+        /// happens to share the port.
+        private func killExistingSocketServerProcesses(port: UInt32) {
+            let pids = outputOfProcess(arguments: [lsofPath, "-t", "-nP", "-iTCP:\(port)", "-sTCP:LISTEN", "-a", "-c", "ruby"])
+                .split(separator: "\n")
+            pids.forEach { _ = outputOfProcess(arguments: ["/bin/kill", "-9", String($0)]) }
+        }
+
+        /// socket_server listens on whichever of 127.0.0.1 and ::1 is free, while the runner connects to `localhost`,
+        /// so a process holding the port on either address would receive the runner's commands.
+        private func abortIfPortIsInUse(_ port: UInt32) {
+            guard isAddressInUse(family: AF_INET, port: port) || isAddressInUse(family: AF_INET6, port: port) else {
+                return
+            }
+            // lsof only lists this user's processes unless run as root
+            let holders = outputOfProcess(arguments: [lsofPath, "-nP", "-iTCP:\(port)", "-sTCP:LISTEN"])
+            let holder = holders.isEmpty ? " by a process of another user" : ":\n\(holders)"
+            log(message: "Port \(port) is already in use on localhost\(holder)\nStop it, or choose another port for the runner with `swiftServerPort`.")
+            exit(1)
+        }
+
+        /// Binding fails with EADDRINUSE when another socket listens on that address and port, whoever owns it.
+        func isAddressInUse(family: Int32, port: UInt32) -> Bool {
+            let socketDescriptor = socket(family, SOCK_STREAM, 0)
+            guard socketDescriptor >= 0 else {
+                return false
+            }
+            defer { close(socketDescriptor) }
+            // Ignore connections left in TIME_WAIT by an earlier run, as the Ruby server does
+            var reuse: Int32 = 1
+            setsockopt(socketDescriptor, SOL_SOCKET, SO_REUSEADDR, &reuse, socklen_t(MemoryLayout<Int32>.size))
+
+            let result: Int32
+            if family == AF_INET {
+                var address = sockaddr_in()
+                address.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
+                address.sin_family = sa_family_t(AF_INET)
+                address.sin_port = in_port_t(UInt16(port).bigEndian)
+                address.sin_addr.s_addr = inet_addr("127.0.0.1")
+                result = withUnsafePointer(to: &address) {
+                    $0.withMemoryRebound(to: sockaddr.self, capacity: 1) { bind(socketDescriptor, $0, socklen_t(MemoryLayout<sockaddr_in>.size)) }
+                }
+            } else {
+                var address = sockaddr_in6()
+                address.sin6_len = UInt8(MemoryLayout<sockaddr_in6>.size)
+                address.sin6_family = sa_family_t(AF_INET6)
+                address.sin6_port = in_port_t(UInt16(port).bigEndian)
+                address.sin6_addr = in6addr_loopback
+                result = withUnsafePointer(to: &address) {
+                    $0.withMemoryRebound(to: sockaddr.self, capacity: 1) { bind(socketDescriptor, $0, socklen_t(MemoryLayout<sockaddr_in6>.size)) }
+                }
+            }
+            return result != 0 && errno == EADDRINUSE
+        }
+
+        /// Only the process we launched counts: another process listening on the port is not our server
+        private func isPortListening(_ port: UInt32, by processIdentifier: Int32) -> Bool {
+            let result = runProcess(arguments: [lsofPath, "-t", "-nP", "-iTCP:\(port)", "-sTCP:LISTEN"])
+            // `env` exits 127 when lsof can't be found. Without this guard the
+            // probe would silently return false on every poll, then kill the
+            // freshly launched server after the 30s timeout with a misleading
+            // "did not start listening" message. Fail fast with the real cause.
+            if result.status == 127 {
+                log(message: "Could not run lsof (\(lsofPath)) to check socket server readiness. lsof ships at /usr/sbin/lsof on macOS; ensure it is installed and reachable.")
+                exit(1)
+            }
+            return result.output.split(separator: "\n").contains { $0 == Substring(String(processIdentifier)) }
+        }
+
+        /// Prefer the absolute macOS path so port checks don't depend on PATH;
+        /// fall back to a PATH lookup if lsof lives somewhere non-standard.
+        private var lsofPath: String {
+            let standardPath = "/usr/sbin/lsof"
+            return FileManager.default.isExecutableFile(atPath: standardPath) ? standardPath : "lsof"
+        }
+
+        private func outputOfProcess(arguments: [String]) -> String {
+            return runProcess(arguments: arguments).output
+        }
+
+        private func runProcess(arguments: [String]) -> (output: String, status: Int32) {
+            let process = Process()
+            let pipe = Pipe()
+            process.launchPath = "/usr/bin/env"
+            process.arguments = arguments
+            process.standardOutput = pipe
+            process.standardError = FileHandle.nullDevice
+            process.launch()
+            process.waitUntilExit()
+            let data = pipe.fileHandleForReading.readDataToEndOfFile()
+            return (String(data: data, encoding: .utf8) ?? "", process.terminationStatus)
+        }
+    #endif
 }
 
 public class Main {

data/fastlane/swift/Matchfile.swift

@@ -17,4 +17,4 @@ public class Matchfile: MatchfileProtocol {
     // during the `init` process, and you won't see this message
 }
 
-// Generated with fastlane 2.240.1
+// Generated with fastlane 2.241.0