fastlane-plugin-create_simulator_devices 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0e9e16ed0de4857cf85fa712f346be0ceda11335896fd9fea73550fdd36c1fde
+  data.tar.gz: 6d1e956f7127169be6bc8505c543313be366be0f41063a417459a512801127ab
+SHA512:
+  metadata.gz: bd836c8046d442771c35103fcb4501f5a811939f1cc66e9d46f80f55b87e29facaa999fcca5c7841457461eb9f9297a1ca6526b5b2c7a5d5f37e3d5b74a0ae9b
+  data.tar.gz: 9f26874142099e933d8eb96da7d30b51f078fcce9b472501c356b653b2e06f37c9e0a0e8fd5ca36db1ebb25086b3e50acd970cd6de83fc1d9d2179d123831648

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 MacPaw Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,68 @@
+# create_simulator_devices plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-create_simulator_devices)
+
+## About create_simulator_devices
+
+This action creates simulator devices.
+
+Usage sample:
+
+```ruby
+available_simulators_list = create_simulator_devices(
+  devices: ['iPhone 15 (17.0)', 'iPhone 16', 'iPhone 14 (16.3)']
+  verbose: false
+)
+# or
+available_simulators_list = create_simulator_devices(
+  devices: 'iPhone 15 (17.0), iPhone 16,iPhone 14 (16.3)'
+  verbose: false
+)
+# Then run tests with a available_simulators_list
+run_tests(
+  devices: available_simulators_list
+)
+```
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-create_simulator_devices`, add it to your project by running:
+
+```bash
+fastlane add_plugin create_simulator_devices
+```
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+# Contributions
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/create_simulator_devices/actions/create_simulator_devices_action.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'fastlane'
+require 'spaceship'
+require_relative '../helpers/create_simulator_devices/runner'
+require_relative '../helpers/create_simulator_devices/models'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      AVAILABLE_SIMULATOR_DEVICES = :AVAILABLE_SIMULATOR_DEVICES
+    end
+
+    CreateSimulatorDevices = ::Fastlane::CreateSimulatorDevices
+
+    # Create simulator devices.
+    class CreateSimulatorDevicesAction < Fastlane::Action
+      UI = ::Fastlane::UI unless defined?(UI)
+
+      attr_accessor :shell_helper
+
+      def self.run(params)
+        verbose = params[:verbose]
+        params[:devices] = params[:devices].split(',').map(&:strip) if params[:devices].is_a?(String)
+        required_devices = params[:devices]
+        UI.user_error!('No devices specified') if required_devices.nil? || required_devices.empty?
+
+        shell_helper = CreateSimulatorDevices::ShellHelper.new(verbose:, action_context: self)
+        runtime_helper = CreateSimulatorDevices::RuntimeHelper.new(cache_dir: params[:cache_dir], shell_helper:, verbose:)
+
+        runner = CreateSimulatorDevices::Runner.new(
+          runtime_helper: runtime_helper,
+          shell_helper: shell_helper,
+          verbose: verbose
+        )
+
+        available_simulator_devices = runner.run(required_devices)
+
+        Actions.lane_context[SharedValues::AVAILABLE_SIMULATOR_DEVICES] = available_simulator_devices
+
+        available_simulator_devices
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Creates simulator devices and installs missing runtimes if needed'
+      end
+
+      def self.details
+        "This action does it best to create simulator devices.
+
+        Usage sample:
+
+        available_simulators_list = create_simulator_devices(
+          devices: ['iPhone 15 (17.0)', 'iPhone 16', 'iPhone 14 (16.3)']
+          verbose: false
+        )"
+      end
+
+      def self.available_options
+        [
+          ::FastlaneCore::ConfigItem.new(key: :devices,
+                                         env_name: 'SCAN_DEVICES',
+                                         description: 'A list of simulator devices to install (e.g. "iPhone 16")',
+                                         is_string: false,
+                                         default_value: 'iPhone 16'),
+          ::FastlaneCore::ConfigItem.new(key: :cache_dir,
+                                         description: 'The directory to cache the simulator runtimes',
+                                         is_string: true,
+                                         default_value: "#{Dir.home}/.cache/create_simulator_devices"),
+          ::FastlaneCore::ConfigItem.new(key: :verbose,
+                                         env_name: 'VERBOSE',
+                                         description: 'Verbose output',
+                                         is_string: false,
+                                         default_value: ::FastlaneCore::Globals.verbose?,
+                                         default_value_dynamic: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['AVAILABLE_SIMULATOR_DEVICES', 'A list of available simulator devices']
+        ]
+      end
+
+      def self.return_value
+        'Returns a list of available simulator devices'
+      end
+
+      def self.authors
+        ['nekrich']
+      end
+
+      def self.is_supported?(_platform) # rubocop:disable Naming/PredicatePrefix
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/apple_build_version.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Fastlane
+  # Create simulator devices.
+  module CreateSimulatorDevices
+    # Compare model for Apple build versions.
+    class AppleBuildVersion
+      def initialize(build_version)
+        return if build_version.nil? || build_version.empty?
+
+        @build_version = build_version
+      end
+
+      def beta?
+        @build_version.length >= 8
+      end
+
+      def <=>(other)
+        lhs_build_version = @build_version
+        rhs_build_version = other.to_s
+
+        return 0 if lhs_build_version == rhs_build_version
+
+        lhs_sdk_version = lhs_build_version[0...3]
+        rhs_sdk_version = rhs_build_version[0...3]
+
+        # Check if the SDK major.minor versions (first 3 characters) are the same.
+        # If they are the same, compare only SDK versions.
+        return lhs_sdk_version <=> rhs_sdk_version if lhs_sdk_version != rhs_sdk_version
+
+        lhs_is_beta = beta?
+        # In case we compare with a string, convert it to the AppleBuildVersion object.
+        rhs_is_beta = AppleBuildVersion.new(rhs_build_version).beta?
+
+        return lhs_is_beta ? -1 : 1 if lhs_is_beta != rhs_is_beta
+
+        # If the build versions are the same length, compare them lexicographically.
+        # Otherwise, compare the length of the build versions.
+        if lhs_build_version.length == rhs_build_version.length
+          lhs_build_version <=> rhs_build_version
+        else
+          # iOS 16.0 Release: 22A3362
+          # iOS 16.0 RC1: 22A348
+          # Trying to compare them lexicographically will return false ("22A3362" < "22A348").
+          # So we need to compare the length of the build versions.
+          lhs_build_version.length <=> rhs_build_version.length
+        end
+      end
+
+      def almost_equal?(other)
+        return false if other.nil?
+
+        lhs_build_version = @build_version
+        rhs_build_version = other.to_s
+
+        lhs_is_beta = beta?
+        rhs_is_beta = AppleBuildVersion.new(rhs_build_version).beta?
+
+        return self == other unless lhs_is_beta && rhs_is_beta && lhs_build_version.length == rhs_build_version.length
+
+        lhs_build_version.chop == rhs_build_version.chop
+      end
+
+      def <(other)
+        (self <=> other).negative?
+      end
+
+      def >(other)
+        (self <=> other).positive?
+      end
+
+      def <=(other)
+        !(self <=> other).positive?
+      end
+
+      def >=(other)
+        !(self <=> other).negative?
+      end
+
+      def eql?(other)
+        (self <=> other).zero?
+      end
+
+      def eq?(other)
+        eql?(other)
+      end
+
+      def ==(other)
+        eql?(other)
+      end
+
+      def hash
+        @build_version.hash
+      end
+
+      def to_s
+        @build_version
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/required_device.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Fastlane
+  module CreateSimulatorDevices
+    # Represents a required runtime.
+    class RequiredDevice
+      attr_accessor :device_type, :os_name, :required_runtime, :available_runtime, :available_device
+
+      def initialize(device_type:, os_name:, required_runtime:, available_runtime:, available_device:)
+        self.device_type = device_type
+        self.os_name = os_name
+        self.required_runtime = required_runtime
+        self.available_runtime = available_runtime
+        self.available_device = available_device
+      end
+
+      def description
+        if required_runtime
+          "#{device_type.name} (#{required_runtime.product_version})"
+        else
+          device_type.name
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/required_runtime.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Fastlane
+  module CreateSimulatorDevices
+    # Represents a required runtime.
+    class RequiredRuntime
+      attr_accessor :sdk_platform, :os_name, :product_version, :product_build_version, :is_latest
+
+      def initialize(sdk_platform:, os_name:, product_version:, product_build_version:, is_latest: false)
+        self.sdk_platform = sdk_platform
+        self.os_name = os_name
+        self.product_version = product_version
+        self.product_build_version = product_build_version
+        self.is_latest = is_latest
+      end
+
+      def runtime_name
+        [os_name, product_version].compact.join(' ')
+      end
+
+      def latest?
+        is_latest
+      end
+
+      def beta?
+        return false unless product_build_version
+
+        product_build_version.beta?
+      end
+
+      def eql?(other)
+        other.sdk_platform == sdk_platform && other.os_name == os_name && other.product_version == product_version && other.product_build_version == product_build_version
+      end
+
+      def hash
+        [sdk_platform, os_name, product_version, product_build_version].compact.hash
+      end
+
+      def description
+        "#{os_name} (#{product_version}, #{product_build_version})"
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/simctl/device.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Fastlane
+  module CreateSimulatorDevices
+    module SimCTL
+      # Represents a device.
+      class Device
+        attr_accessor :udid, :name, :device_type_identifier, :available
+
+        def initialize(name:, udid:, device_type_identifier:, available:)
+          self.name = name
+          self.udid = udid
+          self.device_type_identifier = device_type_identifier
+          self.available = available
+        end
+
+        def available?
+          available
+        end
+
+        def self.from_hash(hash)
+          new(
+            name: hash[:name],
+            udid: hash[:udid],
+            device_type_identifier: hash[:deviceTypeIdentifier],
+            available: hash[:isAvailable]
+          )
+        end
+      end
+    end
+  end
+end
+
+# Example of a device object from `xcrun simctl list devices --json` output:
+#
+# {
+#   "dataPath": "/Users/username/Library/Developer/CoreSimulator/Devices/1C1796E3-AB33-41AB-B3EB-9836CF39E57B/data",
+#   "dataPathSize": 4096,
+#   "logPath": "/Users/username/Library/Logs/CoreSimulator/1C1796E3-AB33-41AB-B3EB-9836CF39E57B",
+#   "udid": "1C1796E3-AB33-41AB-B3EB-9836CF39E57B",
+#   "isAvailable": true,
+#   "deviceTypeIdentifier": "com.apple.CoreSimulator.SimDeviceType.Apple-TV-1080p",
+#   "state": "Shutdown",
+#   "name": "Apple TV"
+# }

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/simctl/device_type.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Fastlane
+  module CreateSimulatorDevices
+    module SimCTL
+      # Represents a device type.
+      class DeviceType
+        attr_accessor :identifier, :name, :product_family
+
+        def initialize(identifier:, name:, product_family:)
+          self.identifier = identifier
+          self.name = name
+          self.product_family = product_family
+        end
+
+        def self.from_hash(hash)
+          new(identifier: hash[:identifier], name: hash[:name], product_family: hash[:productFamily])
+        end
+      end
+    end
+  end
+end
+
+# Example of a device type object from `xcrun simctl list devicetypes --json` output:
+#
+# {
+#   "productFamily" : "iPhone",
+#   "bundlePath" : "/Library/Developer/CoreSimulator/Profiles/DeviceTypes/iPod touch (7th generation).simdevicetype",
+#   "maxRuntimeVersion" : 1048575,
+#   "maxRuntimeVersionString" : "15.255.255",
+#   "identifier" : "com.apple.CoreSimulator.SimDeviceType.iPod-touch--7th-generation-",
+#   "modelIdentifier" : "iPod9,1",
+#   "minRuntimeVersionString" : "12.3.1",
+#   "minRuntimeVersion" : 787201,
+#   "name" : "iPod touch (7th generation)"
+# }

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/simctl/runtime.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative 'runtime_supported_device_type'
+require_relative '../apple_build_version'
+
+module Fastlane
+  module CreateSimulatorDevices
+    module SimCTL
+      # Represents a runtime from `xcrun simctl runtime list --json` output.
+      class RuntimeWithState
+        attr_accessor :identifier, :version, :build, :state, :deletable
+
+        def initialize(identifier:, version:, build:, state:, deletable:)
+          self.identifier = identifier
+          self.version = version
+          self.build = build
+          self.state = state
+          self.deletable = deletable
+        end
+
+        def ready?
+          state == 'Ready'
+        end
+
+        def deletable?
+          deletable
+        end
+
+        def unusable?
+          state == 'Unusable'
+        end
+
+        def self.from_hash(hash)
+          new(
+            identifier: hash[:identifier],
+            version: Gem::Version.new(hash[:version]),
+            build: AppleBuildVersion.new(hash[:build]),
+            state: hash[:state],
+            deletable: hash[:deletable]
+          )
+        end
+      end
+
+      # Represents a runtime from `xcrun simctl list runtimes --json` output.
+      class Runtime
+        attr_accessor :identifier, :platform, :version, :supported_device_types, :build_version, :is_available
+
+        def initialize(identifier:, platform:, version:, supported_device_types:, build_version:, is_available:) # rubocop:disable Metrics/ParameterLists
+          self.identifier = identifier
+          self.platform = platform
+          self.version = version
+          self.supported_device_types = supported_device_types
+          self.build_version = build_version
+          self.is_available = is_available
+        end
+
+        def self.from_hash(hash)
+          build_version = AppleBuildVersion.new(hash[:buildversion]) if hash[:buildversion]
+
+          new(
+            identifier: hash[:identifier],
+            platform: hash[:platform],
+            version: Gem::Version.new(hash[:version]),
+            supported_device_types: hash[:supportedDeviceTypes].map { |device_type| Runtime::SupportedDeviceType.from_hash(device_type) },
+            build_version:,
+            is_available: hash[:isAvailable]
+          )
+        end
+
+        def runtime_name
+          "#{[platform, version].join(' ')} (build #{build_version})"
+        end
+
+        def available?
+          is_available
+        end
+      end
+    end
+  end
+end
+
+# Example of a Runtime object from `xcrun simctl list runtimes --json` output:
+#
+# {
+#   "isAvailable": true,
+#   "version": "17.4",
+#   "isInternal": false,
+#   "buildversion" : "23M5279f",
+#   "supportedArchitectures" : [
+#     "arm64"
+#   ],
+#   "supportedDeviceTypes": [
+#     {
+#       "bundlePath": "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Library/Developer/CoreSimulator/Profiles/DeviceTypes/iPhone 15.simdevicetype",
+#       "name": "iPhone 15",
+#       "identifier": "com.apple.CoreSimulator.SimDeviceType.iPhone-15",
+#       "productFamily": "iPhone"
+#     },
+#     {
+#       "bundlePath": "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Library/Developer/CoreSimulator/Profiles/DeviceTypes/iPhone 15 Pro.simdevicetype",
+#       "name": "iPhone 15 Pro",
+#       "identifier": "com.apple.CoreSimulator.SimDeviceType.iPhone-15-Pro",
+#       "productFamily": "iPhone"
+#     }
+#   ],
+#   "identifier": "com.apple.CoreSimulator.SimRuntime.iOS-17-4",
+#   "platform": "iOS",
+#   "bundlePath": "",
+#   "runtimeRoot": "",
+#   "lastUsage": {
+#     "arm64" : "0001-01-01T00:00:00Z"
+#   },
+#   "name": "iOS 17.4"
+# }

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/simctl/runtime_supported_device_type.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Fastlane
+  module CreateSimulatorDevices
+    module SimCTL
+      class Runtime
+        # Represents a supported device type by a runtime.
+        class SupportedDeviceType
+          attr_accessor :identifier, :name, :product_family
+
+          def initialize(identifier:, name:, product_family:)
+            self.identifier = identifier
+            self.name = name
+            self.product_family = product_family
+          end
+
+          def self.from_hash(hash)
+            new(identifier: hash[:identifier], name: hash[:name], product_family: hash[:productFamily])
+          end
+        end
+      end
+    end
+  end
+end
+
+# Example of a supported device type object from `xcrun simctl list runtimes --json` output:
+#
+# {
+#   "bundlePath": "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Library/Developer/CoreSimulator/Profiles/DeviceTypes/iPhone 15.simdevicetype",
+#   "name": "iPhone 15",
+#   "identifier": "com.apple.CoreSimulator.SimDeviceType.iPhone-15",
+#   "productFamily": "iPhone"
+# }

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/xcodebuild/sdk.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../apple_build_version'
+
+module Fastlane
+  module CreateSimulatorDevices
+    module Xcodebuild
+      # Represents a SDK.
+      class SDK
+        attr_accessor :build_id, :canonical_name, :display_name, :platform, :platform_version, :product_build_version, :sdk_version, :product_name, :product_version
+
+        def initialize(build_id:, canonical_name:, display_name:, platform:, platform_version:, sdk_version:, product_name:, product_version:, product_build_version:) # rubocop:disable Metrics/ParameterLists
+          self.build_id = build_id
+          self.canonical_name = canonical_name
+          self.display_name = display_name
+          self.platform = platform
+          self.platform_version = platform_version
+          self.sdk_version = sdk_version
+          self.product_name = product_name
+          self.product_version = product_version
+          self.product_build_version = product_build_version
+        end
+
+        def self.from_hash(hash)
+          product_version = Gem::Version.new(hash[:productVersion]) if hash[:productVersion]
+          new(
+            build_id: hash[:buildID],
+            canonical_name: hash[:canonicalName],
+            display_name: hash[:displayName],
+            platform: hash[:platform],
+            platform_version: Gem::Version.new(hash[:platformVersion]),
+            sdk_version: Gem::Version.new(hash[:sdkVersion]),
+            product_name: hash[:productName],
+            product_version: product_version,
+            product_build_version: AppleBuildVersion.new(hash[:productBuildVersion])
+          )
+        end
+
+        def simulator?
+          platform.end_with?('simulator')
+        end
+      end
+    end
+  end
+end
+
+# Example of a SDK object from `xcrun xcodebuild -showsdks -json` output:
+#
+# {
+#   "buildID": "F8821DD8-570E-11F0-99A4-5B96CBB013DB",
+#   "canonicalName": "watchsimulator26.0",
+#   "displayName": "Simulator - watchOS 26.0",
+#   "isBaseSdk": true,
+#   "platform": "watchsimulator",
+#   "platformPath": "/Applications/Xcode_26_beta_3.app/Contents/Developer/Platforms/WatchSimulator.platform",
+#   "platformVersion": "26.0",
+#   "productBuildVersion": "23R5307e",
+#   "productCopyright": "1983-2025 Apple Inc.",
+#   "productName": "Watch OS",
+#   "productVersion": "26.0",
+#   "sdkPath": "/Applications/Xcode_26_beta_3.app/Contents/Developer/Platforms/WatchSimulator.platform/Developer/SDKs/WatchSimulator26.0.sdk",
+#   "sdkVersion": "26.0"
+# }

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'models/simctl/device_type'
+require_relative 'models/simctl/device'
+require_relative 'models/simctl/runtime'
+require_relative 'models/simctl/runtime_supported_device_type'
+require_relative 'models/xcodebuild/sdk'
+require_relative 'models/required_device'
+require_relative 'models/required_runtime'
+require_relative 'models/apple_build_version'
+
+module Fastlane
+  # Create simulator devices.
+  module CreateSimulatorDevices
+    UI = ::Fastlane::UI unless defined?(UI)
+  end
+end

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/runner.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative 'runtime_helper'
+
+module Fastlane
+  # Create simulator devices.
+  module CreateSimulatorDevices
+    # Does all the work to create simulator devices.
+    class Runner
+      UI = ::Fastlane::UI unless defined?(UI)
+
+      attr_accessor :shell_helper, :verbose, :runtime_helper
+
+      def initialize(runtime_helper:, shell_helper:, verbose:)
+        self.shell_helper = shell_helper
+        self.verbose = verbose || shell_helper.verbose
+        self.runtime_helper = runtime_helper
+      end
+
+      def run(devices)
+        shell_helper.stop_core_simulator_services
+
+        # Delete unusable runtimes and unavailable devices.
+        runtime_helper.delete_unusable_runtimes
+        delete_unavailable_devices
+
+        # Create distict required devices from a given list of device strings.
+        required_devices = devices
+          .filter_map { |device| required_device_for_device(device) }
+          .uniq { |required_device| [required_device.device_type.name, required_device.required_runtime.product_version] }
+
+        # Install missing runtimes if needed.
+        runtime_helper.install_missing_runtimes(required_devices)
+
+        # Create missing devices for required devices.
+        create_missing_devices(required_devices)
+
+        # Return distinct matched devices strings
+        matched_devices = required_devices
+          .reject { |required_device| required_device.available_device.nil? }
+          .map(&:description)
+
+        UI.user_error!('No available devices found') if matched_devices.empty?
+
+        matched_devices
+      end
+
+      def delete_unavailable_devices
+        return unless shell_helper.available_devices_for_runtimes.values.flatten.any?(&:available?)
+
+        shell_helper.delete_unavailable_devices
+
+        shell_helper.available_devices_for_runtimes(force: true)
+      end
+
+      def available_device_for_required_device(required_device)
+        return nil if required_device.available_runtime.nil?
+
+        available_devices = shell_helper.available_devices_for_runtimes[required_device.available_runtime.identifier.to_sym]
+
+        available_devices.detect { |device| device.device_type_identifier == required_device.device_type.identifier }
+      end
+
+      def create_missing_devices(required_devices)
+        find_runtime_and_device_for_required_devices(required_devices)
+
+        missing_devices = required_devices
+          .select { |required_device| required_device.available_device.nil? }
+
+        return if missing_devices.empty?
+
+        UI.message('Creating missing devices')
+        missing_devices.each do |missing_device|
+          shell_helper.create_device(
+            missing_device.description,
+            missing_device.device_type.identifier,
+            missing_device.available_runtime.identifier
+          )
+        end
+
+        shell_helper.available_devices_for_runtimes(force: true)
+
+        find_runtime_and_device_for_required_devices(missing_devices)
+      end
+
+      def find_runtime_and_device_for_required_devices(required_devices)
+        UI.message('Searching for matching available devices...')
+        required_devices.each do |required_device|
+          required_device.available_runtime = runtime_helper.available_runtime_for_required_device(required_device)
+          required_device.available_device = available_device_for_required_device(required_device)
+        end
+      end
+
+      PRODUCT_FAMILY_TO_OS_NAME = {
+        'iPhone' => 'iOS',
+        'iPad' => 'iOS',
+        'iPod' => 'iOS',
+        'Apple TV' => 'tvOS',
+        'Apple Watch' => 'watchOS',
+        'Apple Vision' => 'xrOS'
+      }.freeze
+
+      def required_device_for_device(device)
+        available_device_types = shell_helper.available_device_types
+
+        device_type = available_device_types.detect do |available_device_type|
+          # Avoid matching "iPhone 16" for the "iPhone 16e" device.
+          "#{device} ".start_with?("#{available_device_type.name} ")
+        end
+
+        unless device_type
+          UI.important("Device type not found for device #{device}")
+          return nil
+        end
+
+        product_family = device_type.product_family
+
+        os_name = PRODUCT_FAMILY_TO_OS_NAME[product_family]
+        device_os_version = device.delete_prefix(device_type.name).strip
+        device_os_version = device_os_version[/\(([\d.]*?)\)/, 1]
+
+        runtime_version = nil
+        unless device_os_version.nil? || device_os_version.empty?
+          device_os_version += '.0' if device_os_version.scan('.').none?
+
+          runtime_version = Gem::Version.new(device_os_version)
+        end
+
+        required_device = RequiredDevice.new(
+          device_type:,
+          os_name:,
+          required_runtime: nil,
+          available_runtime: nil,
+          available_device: nil
+        )
+
+        required_device.required_runtime = runtime_helper.required_runtime_for_device(required_device, runtime_version)
+
+        required_device.required_runtime.nil? ? nil : required_device
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/runtime_helper.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'shell_helper'
+
+module Fastlane
+  module CreateSimulatorDevices
+    # Helper class for managing simulator runtimes.
+    class RuntimeHelper
+      UI = ::Fastlane::UI unless defined?(UI)
+
+      attr_accessor :cache_dir, :shell_helper, :verbose
+
+      def initialize(cache_dir:, shell_helper:, verbose:)
+        self.cache_dir = cache_dir
+        self.shell_helper = shell_helper
+        self.verbose = verbose
+      end
+
+      SDK_PLATFORM_TO_OS_NAME = {
+        'iphonesimulator' => 'iOS',
+        'appletvsimulator' => 'tvOS',
+        'watchsimulator' => 'watchOS',
+        'xrsimulator' => 'xrOS'
+      }.freeze
+
+      def delete_unusable_runtimes
+        deletable_runtimes = shell_helper.installed_runtimes_with_state
+          .select { |runtime| runtime.unusable? && runtime.deletable? }
+
+        return if deletable_runtimes.empty?
+
+        deletable_runtimes.each do |runtime|
+          shell_helper.delete_runtime(runtime.identifier)
+        end
+
+        shell_helper.available_runtimes(force: true)
+      end
+
+      def install_missing_runtimes(required_devices)
+        needed_runtimes = required_devices.filter_map(&:required_runtime).uniq
+
+        missing_runtimes = missing_runtimes(needed_runtimes)
+
+        return if missing_runtimes.empty?
+
+        missing_runtimes.each do |missing_runtime|
+          download_and_install_missing_runtime(missing_runtime)
+        end
+
+        # Update available_runtimes after installing the runtimes.
+        shell_helper.installed_runtimes_with_state
+        shell_helper.available_runtimes(force: true)
+
+        # Check if missing runtimes are available after installing
+        missing_runtimes = missing_runtimes(missing_runtimes)
+
+        # List missing runtimes after attempt to install the runtimes.
+        missing_runtimes(missing_runtimes)
+          .each do |missing_runtime|
+            UI.important("Failed to find/download/install runtime #{missing_runtime.runtime_name}")
+          end
+      end
+
+      def missing_runtimes(needed_runtimes)
+        needed_runtimes.select do |needed_runtime|
+          # Check if available runtimes contain the needed runtime.
+          available_runtime_matching_needed_runtime?(needed_runtime).nil?
+        end
+      end
+
+      def available_runtime_matching_needed_runtime?(needed_runtime)
+        matching_runtimes = shell_helper.available_runtimes
+          .select do |available_runtime|
+            next false if needed_runtime.os_name != available_runtime.platform ||
+                          needed_runtime.product_version != available_runtime.version
+
+            needed_runtime.product_build_version = [needed_runtime.product_build_version, available_runtime.build_version].compact.max
+
+            needed_runtime.product_build_version.almost_equal?(available_runtime.build_version)
+          end
+
+        matching_runtimes.max_by { |available_runtime| [available_runtime.version, available_runtime.build_version] }
+      end
+
+      def available_runtime_for_required_device(required_device)
+        available_runtime = available_runtime_matching_needed_runtime?(required_device.required_runtime)
+
+        if available_runtime.nil?
+          UI.important("Runtime #{required_device.required_runtime.description} not found. Skipping simulator creation for #{required_device.description}...")
+          return nil
+        end
+
+        # Check if the runtime supports the device type.
+        if available_runtime.supported_device_types
+            .none? { |supported_device_type| supported_device_type.identifier == required_device.device_type.identifier }
+          UI.important("Device type #{required_device.device_type.name} is not supported by runtime #{available_runtime.identifier}. Skipping simulator creation for #{required_device.description}...")
+          return nil
+        end
+
+        if available_runtime.nil?
+          UI.important("Runtime #{required_device.required_runtime.description} not found. Skipping simulator creation for #{required_device.description}...")
+          return nil
+        end
+
+        available_runtime
+      end
+
+      def install_missing_runtime(missing_runtime, cached_runtime_file)
+        runtime_name = missing_runtime.runtime_name
+
+        if missing_runtime.product_build_version.nil?
+          UI.important("Failed to find runtime build version for #{runtime_name}")
+          return
+        end
+
+        shell_helper.import_runtime(cached_runtime_file, runtime_name)
+      end
+
+      def download_and_install_missing_runtime(missing_runtime)
+        UI.message("Attempting to install #{missing_runtime.runtime_name} runtime.")
+
+        downloaded_runtime_file = cached_runtime_file(missing_runtime)
+
+        if downloaded_runtime_file.nil?
+          shell_helper.download_runtime(missing_runtime, cache_dir)
+          downloaded_runtime_file = cached_runtime_file(missing_runtime)
+        end
+
+        shell_helper.import_runtime(downloaded_runtime_file, missing_runtime.runtime_name)
+      end
+
+      def runtime_build_version_for_filename(filename)
+        return nil unless filename
+
+        # iphonesimulator_18.4_22E238.dmg
+        # Format: iphonesimulator_VERSION_BUILD.dmg
+        build_version = File.basename(filename, '.dmg').split('_').last
+
+        AppleBuildVersion.new(build_version)
+      end
+
+      def cached_runtime_file(missing_runtime)
+        FileUtils.mkdir_p(cache_dir)
+
+        runtime_dmg_search_pattern = "#{cache_dir}/#{missing_runtime.sdk_platform}_#{missing_runtime.product_version}_"
+
+        # Remove the last character of the build version if it is the latest beta.
+        # Apple can create a new Runtime version and block product build version
+        # shipped with Xcode betas and use the same product version.
+        # E.g. Xcode 26.0 Beta 3 has iOS 26.0 (23A5287e) SDK, but
+        # xcodebuild downloads iphonesimulator_26.0_23A5287g.dmg as latest.
+        runtime_dmg_search_pattern += missing_runtime.product_build_version.to_s.chop if missing_runtime.product_build_version
+        runtime_dmg_search_pattern += '*.dmg'
+
+        runtime_file = Dir
+          .glob(runtime_dmg_search_pattern)
+          .max_by { |filename| runtime_build_version_for_filename(filename) }
+
+        return nil if runtime_file.nil?
+
+        missing_runtime.product_build_version ||= runtime_build_version_for_filename(runtime_file)
+
+        UI.message("Found existing #{missing_runtime.runtime_name} runtime image in #{cache_dir}: #{runtime_file}")
+
+        runtime_file
+      end
+
+      def required_runtime_for_device(required_device, runtime_version)
+        sdk = max_available_simulator_sdks[required_device.os_name]
+
+        # If the runtime version is the same as the SDK version, use the SDK build version.
+        # This will allow to use different runtimes for the same version but different Xcode beta versions.
+        product_build_version = sdk.product_build_version if runtime_version.nil? || sdk.product_version == runtime_version
+
+        if !runtime_version.nil? && runtime_version > sdk.product_version
+          UI.important("Runtime version for #{required_device.device_type.name} (#{runtime_version}) is higher than maximum supported by the Xcode: #{sdk.product_version}")
+          return nil
+        end
+
+        RequiredRuntime.new(
+          sdk_platform: sdk.platform,
+          os_name: required_device.os_name,
+          product_version: runtime_version || sdk.product_version,
+          product_build_version:,
+          is_latest: sdk.product_build_version.almost_equal?(product_build_version)
+        )
+      end
+
+      # Returns a hash where key is platform string and value is sdk version.
+      def max_available_simulator_sdks
+        return @max_available_simulator_sdks unless @max_available_simulator_sdks.nil?
+
+        @max_available_simulator_sdks = shell_helper.available_sdks
+          # Only simulators
+          .filter { |sdk| sdk.platform.include?('simulator') }
+          # Calculate max version for each product name
+          .each_with_object({}) do |sdk, sdk_versions|
+            os_name = SDK_PLATFORM_TO_OS_NAME[sdk.platform]
+            stored_sdk = sdk_versions[os_name]
+            sdk_versions[os_name] = sdk if stored_sdk.nil? || sdk.product_version > stored_sdk.product_version
+          end
+
+        @max_available_simulator_sdks
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/shell_helper.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative 'models'
+
+module Fastlane
+  # Create simulator devices.
+  module CreateSimulatorDevices
+    # Shell helper
+    class ShellHelper
+      UI = ::Fastlane::UI unless defined?(UI)
+
+      # Proprty verbose
+      attr_accessor :verbose, :action_context
+
+      def initialize(verbose: false, action_context: nil)
+        self.verbose = verbose
+        self.action_context = action_context
+      end
+
+      def sh(command:, print_command: verbose, print_command_output: verbose)
+        if action_context
+          action_context.sh(command, print_command:, print_command_output:)
+        else
+          # Fallback for testing or direct usage
+          require 'open3'
+          stdout, stderr, status = Open3.capture3(command)
+
+          UI.message command if print_command
+
+          if status.success?
+            UI.message stdout if print_command_output
+            stdout
+          else
+            error_message = "Command failed: #{command}\n#{stderr}"
+            UI.error error_message
+            raise StandardError, error_message
+          end
+        end
+      end
+
+      def stop_core_simulator_services
+        UI.message('Stop CoreSimulator')
+        services_to_stop = [
+          'com.apple.CoreSimulator.CoreSimulatorService',
+          'com.apple.CoreSimulator.SimulatorTrampoline',
+          'com.apple.CoreSimulator.SimLaunchHost-arm64',
+          'com.apple.CoreSimulator.SimLaunchHost-x86'
+        ]
+        services_to_stop.each do |service|
+          sh(command: "launchctl remove #{service} || true")
+        end
+      end
+
+      def available_device_types(force: false)
+        return @available_device_types unless force || @available_device_types.nil?
+
+        UI.message('Fetching available device types...')
+        json = sh(command: 'xcrun simctl list --json --no-escape-slashes devicetypes')
+
+        @available_device_types = JSON
+          .parse(json, symbolize_names: true)[:devicetypes]
+          .map { |device_type| SimCTL::DeviceType.from_hash(device_type) }
+
+        @available_device_types
+      end
+
+      def delete_device(udid)
+        UI.message("Deleting device #{udid}...")
+        sh(command: "xcrun simctl delete #{udid.shellescape}")
+      end
+
+      def delete_unavailable_devices
+        UI.message('Deleting unavailable devices...')
+        sh(command: 'xcrun simctl delete unavailable')
+      end
+
+      def available_devices_for_runtimes(force: false)
+        return @available_devices_for_runtimes unless force || @available_devices_for_runtimes.nil?
+
+        UI.message('Fetching available devices...')
+        json = sh(command: 'xcrun simctl list --json --no-escape-slashes devices')
+
+        @available_devices_for_runtimes = JSON
+          .parse(json, symbolize_names: true)[:devices]
+          .transform_values { |devices| devices.map { |device| SimCTL::Device.from_hash(device) } }
+
+        @available_devices_for_runtimes
+      end
+
+      def available_runtimes(force: false)
+        return @available_runtimes unless force || @available_runtimes.nil?
+
+        UI.message('Fetching available runtimes...')
+        json = sh(command: 'xcrun simctl list --json --no-escape-slashes runtimes')
+
+        @available_runtimes = JSON
+          .parse(json, symbolize_names: true)[:runtimes]
+          .map { |runtime| SimCTL::Runtime.from_hash(runtime) }
+          .select(&:available?)
+
+        @available_runtimes
+      end
+
+      def installed_runtimes_with_state
+        UI.message('Fetching runtimes with state...')
+        json = sh(command: 'xcrun simctl runtime list --json')
+
+        JSON
+          .parse(json, symbolize_names: true)
+          .map { |_, runtime| SimCTL::RuntimeWithState.from_hash(runtime) }
+      end
+
+      def available_sdks(force: false)
+        return @available_sdks unless force || @available_sdks.nil?
+
+        UI.message('Fetching available sdks...')
+        json = sh(command: 'xcrun xcodebuild -showsdks -json')
+
+        @available_sdks = JSON
+          .parse(json, symbolize_names: true)
+          .map { |sdk| Xcodebuild::SDK.from_hash(sdk) }
+
+        @available_sdks
+      end
+
+      def create_device(name, device_type_identifier, runtime_identifier)
+        UI.message("Creating device #{name}")
+        sh(command: "xcrun simctl create #{name.shellescape} #{device_type_identifier.shellescape} #{runtime_identifier.shellescape}")
+      end
+
+      def delete_runtime(runtime_identifier)
+        UI.message("Deleting runtime #{runtime_identifier}...")
+        sh(command: "xcrun simctl runtime delete #{runtime_identifier.shellescape}")
+      end
+
+      def download_runtime(missing_runtime, cache_dir)
+        UI.message("Downloading #{missing_runtime.runtime_name} to #{cache_dir}. This may take a while...")
+
+        command = [
+          'xcrun',
+          'xcodebuild',
+          '-verbose',
+
+          '-exportPath',
+          cache_dir.shellescape,
+
+          '-downloadPlatform',
+          missing_runtime.os_name.shellescape
+        ]
+
+        unless missing_runtime.latest?
+          command << '-buildVersion'
+          # Prefer the build version if available, otherwise use the product version.
+          command << (missing_runtime.product_build_version || missing_runtime.product_version.to_s).shellescape
+        end
+
+        sh(command: command.join(' '), print_command: true, print_command_output: true)
+      end
+
+      def import_runtime(runtime_dmg_filename, runtime_name)
+        UI.message("Importing runtime #{runtime_name} image from #{runtime_dmg_filename}...")
+        import_platform_command = "xcrun xcodebuild -verbose -importPlatform #{runtime_dmg_filename.shellescape}"
+        begin
+          sh(command: import_platform_command)
+        rescue StandardError => e
+          UI.important("Failed to import runtime #{runtime_name} with '#{import_platform_command}' :\n#{e}")
+        end
+      end
+
+      # def add_runtime(runtime_dmg_filename, runtime_name)
+      #   UI.message("Adding runtime #{runtime_name}...")
+      #   add_runtime_command = "xcrun simctl runtime add #{runtime_dmg_filename.shellescape}"
+      #   begin
+      #     sh(command: add_runtime_command)
+      #   rescue StandardError => e
+      #     UI.important("Failed to add runtime #{runtime_name} with '#{add_runtime_command}':\n#{e}")
+      #   end
+      # end
+    end
+  end
+end

data/lib/fastlane/plugin/create_simulator_devices/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Fastlane
+  module CreateSimulatorDevices
+    VERSION = '0.0.1'
+  end
+end

data/lib/fastlane/plugin/create_simulator_devices.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'fastlane/plugin/create_simulator_devices/version'
+
+module Fastlane
+  # Creates missing simulator devices.
+  module CreateSimulatorDevices
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helpers}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::CreateSimulatorDevices.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-create_simulator_devices
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Vitalii Budnik
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-07-17 00:00:00.000000000 Z
+dependencies: []
+description:
+email: developers@setapp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/create_simulator_devices.rb
+- lib/fastlane/plugin/create_simulator_devices/actions/create_simulator_devices_action.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/apple_build_version.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/required_device.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/required_runtime.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/simctl/device.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/simctl/device_type.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/simctl/runtime.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/simctl/runtime_supported_device_type.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/xcodebuild/sdk.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/runner.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/runtime_helper.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/shell_helper.rb
+- lib/fastlane/plugin/create_simulator_devices/version.rb
+homepage:
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Fastlane plugin to create simulator devices
+test_files: []