fastlane 2.238.0 → 2.241.0

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.238.0
+// Generated with fastlane 2.241.0

data/fastlane/swift/GymfileProtocol.swift

@@ -152,6 +152,9 @@ public protocol GymfileProtocol: AnyObject {
     /// Skips resolution of Swift Package Manager dependencies
     var skipPackageDependenciesResolution: Bool { get }
 
+    /// Raises an error instead of fetching build settings by running `xcodebuild -showBuildSettings`, which can take a long time on large projects. The error names the required build setting, so the corresponding option can be specified manually
+    var disallowXcodebuildSettingsLookup: Bool { get }
+
     /// Prevents packages from automatically being resolved to versions other than those recorded in the `Package.resolved` file. This translates in the option `-disableAutomaticPackageResolution` being passed to xcodebuild
     var disablePackageAutomaticUpdates: Bool { get }
 
@@ -369,6 +372,10 @@ public extension GymfileProtocol {
         return false
     }
 
+    var disallowXcodebuildSettingsLookup: Bool {
+        return false
+    }
+
     var disablePackageAutomaticUpdates: Bool {
         return false
     }
@@ -392,4 +399,4 @@ public extension GymfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.155]
+// 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.238.0
+// Generated with fastlane 2.241.0

data/fastlane/swift/MatchfileProtocol.swift

@@ -56,10 +56,10 @@ public protocol MatchfileProtocol: AnyObject {
     /// Clone just the branch specified, instead of the whole repo. This requires that the branch already exists. Otherwise the command will fail
     var cloneBranchDirectly: Bool { get }
 
-    /// Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64
+    /// 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
     var gitBasicAuthorization: String? { get }
 
-    /// Use a bearer authorization header to access the git repo (e.g.: access to an Azure DevOps repository), usually a string in Base64
+    /// 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
     var gitBearerAuthorization: String? { get }
 
     /// 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
@@ -173,6 +173,9 @@ public protocol MatchfileProtocol: AnyObject {
     /// Force encryption to use legacy cbc algorithm for backwards compatibility with older match versions
     var forceLegacyEncryption: Bool { get }
 
+    /// Enable profile with 'Offline Support' (7 day validity). Requires Apple ID login, not supported with App Store Connect API key authentication
+    var offlineProfile: Bool { get }
+
     /// Print out extra information and all commands
     var verbose: Bool { get }
 }
@@ -406,6 +409,10 @@ public extension MatchfileProtocol {
         return false
     }
 
+    var offlineProfile: Bool {
+        return false
+    }
+
     var verbose: Bool {
         return false
     }
@@ -413,4 +420,4 @@ public extension MatchfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.149]
+// FastlaneRunnerAPIVersion [0.9.153]

data/fastlane/swift/Precheckfile.swift

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

data/fastlane/swift/PrecheckfileProtocol.swift

@@ -84,4 +84,4 @@ public extension PrecheckfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.148]
+// FastlaneRunnerAPIVersion [0.9.152]

data/fastlane/swift/Scanfile.swift

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

data/fastlane/swift/ScanfileProtocol.swift

@@ -77,6 +77,9 @@ public protocol ScanfileProtocol: AnyObject {
     /// Should the thread sanitizer be turned on?
     var threadSanitizer: Bool? { get }
 
+    /// 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)
+    var collectTestDiagnostics: String? { get }
+
     /// Should the HTML report be opened when tests are completed?
     var openReport: Bool { get }
 
@@ -230,6 +233,9 @@ public protocol ScanfileProtocol: AnyObject {
     /// Skips resolution of Swift Package Manager dependencies
     var skipPackageDependenciesResolution: Bool { get }
 
+    /// Raises an error instead of fetching build settings by running `xcodebuild -showBuildSettings`, which can take a long time on large projects. The error names the required build setting, so the corresponding option can be specified manually
+    var disallowXcodebuildSettingsLookup: Bool { get }
+
     /// Prevents packages from automatically being resolved to versions other than those recorded in the `Package.resolved` file. This translates in the option `-disableAutomaticPackageResolution` being passed to xcodebuild
     var disablePackageAutomaticUpdates: Bool { get }
 
@@ -350,6 +356,10 @@ public extension ScanfileProtocol {
         return nil
     }
 
+    var collectTestDiagnostics: String? {
+        return nil
+    }
+
     var openReport: Bool {
         return false
     }
@@ -554,6 +564,10 @@ public extension ScanfileProtocol {
         return false
     }
 
+    var disallowXcodebuildSettingsLookup: Bool {
+        return false
+    }
+
     var disablePackageAutomaticUpdates: Bool {
         return false
     }
@@ -581,4 +595,4 @@ public extension ScanfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.160]
+// FastlaneRunnerAPIVersion [0.9.164]

data/fastlane/swift/Screengrabfile.swift

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

data/fastlane/swift/ScreengrabfileProtocol.swift

@@ -161,4 +161,4 @@ public extension ScreengrabfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.150]
+// FastlaneRunnerAPIVersion [0.9.154]

data/fastlane/swift/Snapshotfile.swift

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

data/fastlane/swift/SnapshotfileProtocol.swift

@@ -125,6 +125,9 @@ public protocol SnapshotfileProtocol: AnyObject {
     /// Skips resolution of Swift Package Manager dependencies
     var skipPackageDependenciesResolution: Bool { get }
 
+    /// Raises an error instead of fetching build settings by running `xcodebuild -showBuildSettings`, which can take a long time on large projects. The error names the required build setting, so the corresponding option can be specified manually
+    var disallowXcodebuildSettingsLookup: Bool { get }
+
     /// Prevents packages from automatically being resolved to versions other than those recorded in the `Package.resolved` file. This translates in the option `-disableAutomaticPackageResolution` being passed to xcodebuild
     var disablePackageAutomaticUpdates: Bool { get }
 
@@ -327,6 +330,10 @@ public extension SnapshotfileProtocol {
         return false
     }
 
+    var disallowXcodebuildSettingsLookup: Bool {
+        return false
+    }
+
     var disablePackageAutomaticUpdates: Bool {
         return false
     }
@@ -378,4 +385,4 @@ public extension SnapshotfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.144]
+// FastlaneRunnerAPIVersion [0.9.148]

data/fastlane/swift/formatting/Rakefile

@@ -14,5 +14,6 @@ end
 task(:lint) do
   Dir.chdir('..') do
     sh("swiftformat . --config formatting/.swiftformat --verbose --selfrequired waitWithPolling --exclude Fastfile.swift --swiftversion 4.0")
+    sh("swiftformat ../spec/swift --config formatting/.swiftformat --verbose --swiftversion 4.0")
   end
 end

data/fastlane/swift/main.swift

@@ -11,6 +11,9 @@
 import Foundation
 
 let argumentProcessor = ArgumentProcessor(args: CommandLine.arguments)
+/// fastlane reads this from the built runner, to tell whether it is outdated. Increase it when the runner changes how it talks to fastlane.
+let runnerProtocolVersion = "FastlaneRunnerProtocolVersion [1]"
+verbose(message: runnerProtocolVersion)
 let timeout = argumentProcessor.commandTimeout
 
 class MainProcess {
@@ -44,4 +47,4 @@ while !process.doneRunningLane, RunLoop.current.run(mode: RunLoopMode.defaultRun
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.2]
+// FastlaneRunnerAPIVersion [0.9.3]

data/fastlane_core/README.md

@@ -72,7 +72,7 @@ UI.deprecated("The '--key' parameter is deprecated")
 ```
 
 # Code of Conduct
-Help us keep _fastlane_ open and inclusive. Please read and follow our [Code of Conduct](https://github.com/fastlane/fastlane/blob/master/CODE_OF_CONDUCT.md).
+Help us keep _fastlane_ open and inclusive. Please read and follow our [Code of Conduct](https://github.com/fastlane/fastlane/blob/master/docs/CODE_OF_CONDUCT.md).
 
 # License
 This project is licensed under the terms of the MIT license. See the LICENSE file.

data/fastlane_core/lib/fastlane_core/analytics/analytics_event_builder.rb

@@ -21,7 +21,7 @@ module FastlaneCore
         params: {
           fastlane_client_language: @fastlane_client_language,
           fastlane_version: Fastlane::VERSION,
-          install_method: install_method,
+          install_method: Helper.install_method,
           ruby_version: RUBY_VERSION,
           operating_system: Helper.operating_system,
           build_tool_version: @build_tool_version,
@@ -29,21 +29,5 @@ module FastlaneCore
         }.reject { |_, value| value.nil? }
       }
     end
-
-    private
-
-    def install_method
-      if Helper.bundler?
-        'bundler'
-      elsif Helper.contained_fastlane?
-        'standalone'
-      elsif Helper.homebrew?
-        'homebrew'
-      elsif Helper.mac_app?
-        'mac_app'
-      else
-        'gem'
-      end
-    end
   end
 end

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

@@ -1,5 +1,6 @@
 require_relative '../helper'
 require_relative '../globals'
+require_relative '../secrets'
 require_relative 'config_item'
 require_relative 'commander_generator'
 require_relative 'configuration_file'
@@ -53,16 +54,17 @@ module FastlaneCore
       # used for pushing and popping values to provide nesting configuration contexts
       @values_stack = []
 
-      # if we are in captured output mode - keep a array of sensitive option values
-      # those will be later - replaced by ####
-      if FastlaneCore::Globals.capture_output?
-        available_options.each do |element|
-          next unless element.sensitive
-          self.class.sensitive_strings << values[element.key]
-        end
+      verify_input_types
+
+      @available_options.each do |element|
+        next unless element.sensitive
+
+        Secrets.register(@values[element.key], name: element.key)
+        # if we are in captured output mode - keep a array of sensitive option values
+        # those will be later - replaced by ####
+        self.class.sensitive_strings << @values[element.key] if FastlaneCore::Globals.capture_output?
       end
 
-      verify_input_types
       verify_value_exists
       verify_no_duplicates
       verify_conflicts
@@ -229,6 +231,7 @@ module FastlaneCore
 
       value = option.auto_convert_value(value)
       value = nil if value.nil? && !option.string? # by default boolean flags are false
+      Secrets.register(value, name: option.key) if option.sensitive
       return value unless value.nil? && (!option.optional || force_ask) && ask
 
       # fallback to asking
@@ -267,6 +270,18 @@ module FastlaneCore
     end
     # rubocop:enable Metrics/PerceivedComplexity
 
+    # Returns true if the value for a certain key comes from one of the sources `fetch` checks
+    # before falling back to the default value: passed in, an environment variable or the config file
+    def specified?(key)
+      UI.crash!("Key '#{key}' must be a symbol. Example :#{key}") unless key.kind_of?(Symbol)
+
+      option = verify_options_key!(key)
+
+      !@values[key].nil? ||
+        !option.fetch_env_value.nil? ||
+        self.config_file_options.key?(key)
+    end
+
     # Overwrites or sets a new value for a given key
     # @param key [Symbol] Must be a symbol
     def set(key, value)

data/fastlane_core/lib/fastlane_core/device_manager.rb

@@ -243,7 +243,7 @@ module FastlaneCore
         plist_buddy_cmd = "-c \"Add :KeyboardContinuousPathEnabled bool false\""
         plist_path = File.expand_path("~/Library/Developer/CoreSimulator/Devices/#{self.udid}/data/Library/Preferences/com.apple.keyboard.ContinuousPath.plist")
 
-        Helper.backticks("#{plist_buddy} #{plist_buddy_cmd} #{plist_path} >/dev/null 2>&1")
+        Helper.backticks("#{plist_buddy} #{plist_buddy_cmd} #{plist_path.shellescape} >/dev/null 2>&1")
       end
     end
   end
@@ -300,7 +300,7 @@ module FastlaneCore
 
         UI.verbose("Launching #{simulator_path} for device: #{device.name} (#{device.udid})")
 
-        Helper.backticks("open -a #{simulator_path} --args -CurrentDeviceUDID #{device.udid}", print: FastlaneCore::Globals.verbose?)
+        Helper.backticks("open -a #{simulator_path.shellescape} --args -CurrentDeviceUDID #{device.udid}", print: FastlaneCore::Globals.verbose?)
       end
 
       def copy_logs(device, log_identity, logs_destination_dir, log_collection_start_time)

data/fastlane_core/lib/fastlane_core/fastlane_pty.rb

@@ -30,6 +30,11 @@ module FastlaneCore
       require 'pty'
       # this forces the PTY flush - fixes #21792
       command = ENV['FASTLANE_EXEC_FLUSH_PTY_WORKAROUND'] ? "#{original_command};" : original_command
+      # The status is produced in the ensure below and read after the block. It
+      # travels in a local rather than in $?, which is a thread global: anything
+      # that runs a subprocess in between overwrites it, and nothing writes it at
+      # all when the wait does not happen. See fastlane#30188.
+      status = nil
       PTY.spawn(command) do |command_stdout, command_stdin, pid|
         begin
           yield(command_stdout, command_stdin, pid)
@@ -42,20 +47,28 @@ module FastlaneCore
           command_stdin.close
           command_stdout.close
           begin
-            Process.wait(pid)
-          rescue Errno::ECHILD, PTY::ChildExited
-            # The process might have exited.
+            _pid, status = Process.wait2(pid)
+          rescue PTY::ChildExited => e
+            # The pty saw the child go before we asked for it. The exception
+            # carries the status we were about to wait for.
+            status = e.status
+          rescue Errno::ECHILD
+            # Something else reaped it, so there is nothing left to ask for. $?
+            # may still hold it, and may just as easily hold someone else's.
           end
         end
       end
-      status = self.process_status
+      status ||= self.process_status
+      # Better a plain error than a NoMethodError raised from inside the handler
+      # that exists to report the failure, which is what nil used to produce.
+      raise StandardError, "Could not determine the exit status of the command" if status.nil?
       raise StandardError, "Process crashed" if status.signaled?
       status.exitstatus
     rescue StandardError => e
       # Wrapping any error in FastlanePtyError to allow callers to see and use
-      # $?.exitstatus that would usually get returned
-      status = self.process_status
-      raise FastlanePtyError.new(e, status.exitstatus || e.exit_status, status)
+      # the exit status that would usually get returned
+      status ||= self.process_status
+      raise FastlanePtyError.new(e, status&.exitstatus || e.exit_status, status)
     end
 
     def self.spawn_with_popen(command, &block)