firespring_dev_commands 3.1.4.pre.alpha.2 → 3.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98540f7343c01ce44def76e18d8ea30698a87f4e05eee628a2f940eea74684b2
-  data.tar.gz: 26efe70e7b456b1d9435a5cdf7cfbabad0e1eb61031c7c50fc2555fac45b139f
+  metadata.gz: 179df75f7b62c175947f2cf19da1d3cd99711dc1e5e430567810e57afdc41c61
+  data.tar.gz: f1d69c062cdc5df63aa9b4786ffc2f706ed9acb0450adf9fc1221a9f4426d0f6
 SHA512:
-  metadata.gz: d944c4da021b6b2a9e2144112023d270a891f380c579d98f4b5f915b9c0b43328d4153f90f5a05d3b1290158f143fca7f0cf09b3937cb2930d7fb3c6221ccbe0
-  data.tar.gz: 249e0ec0d7c3a27a146137cfbc889f775fcc8a7efbafdcdc9e2e37f8c0f8d4e47628ad159de0cd222a45123e6b41cd2381e5d4f400d68bb927833a223f376454
+  metadata.gz: 6defd1186a7d99b941b8cdb89d9fce77d828694c66aaee7eb24df27aabed58aded31a2bf0b72b0e95057c5e0053a0a6d7e93e279ba5509f03a8f9598c7f1a354
+  data.tar.gz: '09268007596b27dbda45ee0afe4eb8d93330078d1d03f39bfa38856ef0f9175a59f025c4b6f1dc420e3d0838abaf5d2727d9b7511e1bac88cc9b8cdf4c2ebd42'

data/lib/firespring_dev_commands/aws/route53.rb

@@ -1,44 +1,59 @@
+require 'aws-sdk-route53'
+
 module Dev
   class Aws
     # Class for performing Route53 functions
     class Route53
       attr_reader :client
 
-      def initialize(domains)
+      def initialize(domains = nil)
         @client = ::Aws::Route53::Client.new
-        @domains = domains
+        @domains = Array(domains || [])
       end
 
-      private def zones
+      def zones(&)
         if @domains.empty?
-          all_zones
+          each_zone(&)
         else
-          zones_by_domain_names(@domains)
+          each_zone_by_domains(&)
         end
       end
 
-      private def all_zones
-        [].tap do |ary|
-          Dev::Aws.each_page(client, :list_hosted_zones) do |response|
-            response.hosted_zones&.each do |hosted_zone|
-              ary << hosted_zone unless hosted_zone.config.private_zone
-            end
+      private def each_zone
+        Dev::Aws.each_page(client, :list_hosted_zones) do |response|
+          response.hosted_zones&.each do |hosted_zone|
+            next if hosted_zone.config.private_zone
+
+            yield hosted_zone
           end
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         end
       end
 
-      private def zones_by_domain_names(domains)
-        [].tap do |ary|
-          domains.each do |domain_name|
-            response = client.list_hosted_zones_by_name({dns_name: domain_name})
-            target = response.hosted_zones.find { |it| it.name.chomp('.') == domain_name }
-            raise "The #{domain_name} hosted zone not found." unless target
+      private def each_zone_by_domains(&)
+        @domains.each do |domain|
+          response = client.list_hosted_zones_by_name({dns_name: domain})
 
-            ary << target
-          end
+          # The 'list_hosted_zones_by_name' returns fuzzy matches (so "foo.com" would return both "bar.foo.com" and "foo.com"
+          # So we are only selecting domains that match exactly since that's what we really want here
+          targets = response.hosted_zones.select { |it| it.name.chomp('.') == domain }
+          raise "The #{domain} hosted zone not found." if targets.empty?
+
+          targets.each(&)
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         end
       end
 
+      private def ip_address(domain)
+        Addrinfo.ip(domain.to_s.strip)&.ip_address
+      rescue SocketError
+        "Unable to resolve domain: #{domain}"
+      end
+
       private def target_config_id(zone_id)
         client.list_query_logging_configs(
           hosted_zone_id: zone_id,
@@ -46,61 +61,78 @@ module Dev
         ).query_logging_configs&.first&.id
       end
 
-      private def pretty_puts(output)
-        # Find the maximum length of the keys
-        max_key_length = output.keys.map(&:to_s).max_by(&:length).length
+      # Get the hosted zone details for the zone id
+      private def details(zone_id)
+        response = client.get_hosted_zone(id: zone_id)
+        [response.hosted_zone, response.delegation_set]
+      end
+
+      def list_zone_details
+        zones do |zone|
+          puts
+          zone_details, delegation_set = details(zone.id)
+          dns_resource = Dev::Dns::Resource.new(zone_details.name)
 
-        output.each do |key, value|
-          puts "#{key.to_s.ljust(max_key_length)}\t=>\t#{value}"
+          puts "#{zone_details.name.chomp('.').light_white} (#{zone_details.id}):"
+          puts format('  %-50s %s', 'Delegation Set:', delegation_set.id)
+          puts format('  %-50s %s', 'Delegation Defined Nameservers:', delegation_set.name_servers.sort.join(', '))
+          puts format('  %-50s %s', 'DNS Reported Nameservers:', dns_resource.recursive_nameserver_lookup.sort.join(', '))
+          puts format('  %-50s %s', 'DNS Reported Nameserver IPs:', dns_resource.recursive_nameserver_lookup.sort.map { |it| dns_resource.recursive_a_lookup(it) }.join(', '))
+          puts format('  %-50s %s', 'Domain Apex IP Resolution:', dns_resource.recursive_a_lookup.sort.join(', '))
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         end
+        puts
       end
 
       def list_query_configs
-        output = {}
-        zones.each do |zone|
+        zones do |zone|
           target_config_id = target_config_id(zone.id)
-
-          output[zone.name] = if target_config_id
-                                "Config\t=>\t#{target_config_id}".colorize(:green)
-                              else
-                                'No query logging config assigned.'.colorize(:red)
-                              end
+          message = if target_config_id
+                      "Config\t=>\t#{target_config_id}".colorize(:green)
+                    else
+                      'No query logging config assigned.'.colorize(:red)
+                    end
+          puts format('%-50s => %s', zone.name, message)
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         end
-
-        pretty_puts(output)
       end
 
       def activate_query_logging(log_group)
-        output = {}
-
-        zones.each do |zone|
+        zones do |zone|
           response = client.create_query_logging_config(
             hosted_zone_id: zone.id,
             cloud_watch_logs_log_group_arn: log_group
           )
-          output[zone.id] = response.location
+          puts format('%-50s => %s', zone.id, response.location)
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         rescue ::Aws::Route53::Errors::ServiceError => e
           raise "Error: #{e.message}" unless e.instance_of?(::Aws::Route53::Errors::QueryLoggingConfigAlreadyExists)
 
-          output[zone.id] = e.message
+          puts format('%-50s => %s', zone.id, e.message)
         end
-        pretty_puts(output)
       end
 
       def deactivate_query_logging
-        output = {}
-        zones.each do |zone|
+        zones do |zone|
           target_config_id = target_config_id(zone.id)
           if target_config_id
             client.delete_query_logging_config(
               id: target_config_id
             )
-            output[zone.id] = 'Query logging config removed.'.colorize(:green)
+            puts format('%-50s => %s', zone.id, 'Query logging config removed.'.colorize(:green))
           else
-            output[zone.id] = 'No query logging config assigned.'.colorize(:red)
+            puts format('%-50s => %s', zone.id, 'No query logging config assigned.'.colorize(:red))
           end
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         end
-        pretty_puts(output)
       end
     end
   end

data/lib/firespring_dev_commands/dns/resource.rb

@@ -0,0 +1,83 @@
+module Dev
+  class Dns
+    class Resource
+      attr_reader :domain
+
+      def initialize(domain)
+        @domain = domain
+      end
+
+      # Returns whether or not the given value is a valid IPv4 or IPv6 address
+      def self.ip?(value)
+        ipv4?(value) || ipv6?(value)
+      end
+
+      # Returns whether or not the given value is a valid IPv4 address
+      def self.ipv4?(value)
+        value.match?(Resolv::IPv4::Regex)
+      end
+
+      # Returns whether or not the given value is a valid IPv6 address
+      def self.ipv6?(value)
+        value.match?(Resolv::IPv6::Regex)
+      end
+
+      # Recursively determine the correct nameservers for the given domain.
+      # If nameservers are not found, strip subdomains off until we've reached the TLD
+      def recursive_nameserver_lookup(name = domain)
+        records = lookup(name, type: Resolv::DNS::Resource::IN::NS)
+
+        # Strip the subdomain and try again if we didn't find any nameservers (this can happen with wildcards)
+        return recursive_nameserver_lookup(name.split('.', 2).last) if records.empty?
+
+        # Look up the IPs for the nameservers
+        records
+      end
+
+      # Recursively attempt to find an A record for the given domain.
+      # If one isn't found, also check for CNAMEs continually until we have either found an IP or run out of things to check
+      def recursive_a_lookup(name = domain)
+        # Try looking up an A record first. If we find one, we are done.
+        records = lookup(name, type: Resolv::DNS::Resource::IN::A)
+        return records unless records.empty?
+
+        # Try looking up a CNAME record
+        records = lookup(name, type: Resolv::DNS::Resource::IN::CNAME)
+
+        # If we didn't find an A record _or_ a CNAME, just return empty
+        return records if records.empty?
+
+        # If we found more than one CNAME that is a DNS error
+        raise "Found more than one CNAME entry for #{name}. This is not allowed by DNS" if records.length > 1
+
+        recursive_a_lookup(records.first)
+      end
+
+      # Lookup the given name using the record type provided.
+      def lookup(name = domain, type: Resolv::DNS::Resource::IN::A)
+        # Validate the type
+        raise 'lookup type must be a Resolv::DNS::Resource' unless type.ancestors.include?(Resolv::DNS::Resource)
+
+        # If we were given a tld, return empty
+        return [] unless name.include?('.')
+
+        # Look up NS records for the given host
+        records = Resolv::DNS.new.getresources(name, type)
+
+        # Return the record names
+        records.map do |record|
+          if record.respond_to?(:address)
+            record.address.to_s
+          elsif record.respond_to?(:name)
+            record.name.to_s
+          else
+            ''
+          end
+        end
+      rescue
+        sleep(1)
+        retry
+      end
+    end
+  end
+end

data/lib/firespring_dev_commands/docker/desktop.rb

@@ -46,12 +46,14 @@ services:
           ::Docker.url = 'tcp://127.0.0.1:23750'
 
         else
+          context = Dev::Common.new.run_command(
+            "docker context inspect --format '{{.Endpoints.docker.Host}}'",
+            capture: true
+          ).to_s.strip
+          raise 'context is empty' unless context
+
           # If a user based socket has been defined, default to that
-          ::Docker.url = if File.exist?("/#{Dir.home}/.docker/run/docker.sock")
-                           "unix://#{Dir.home}/.docker/run/docker.sock"
-                         elsif File.exist?("/#{Dir.home}/.docker/desktop/docker.sock")
-                           "unix://#{Dir.home}/.docker/desktop/docker.sock"
-                         end
+          ::Docker.url = context
         end
       end
     end

data/lib/firespring_dev_commands/git.rb

@@ -1,5 +1,6 @@
 require 'fileutils'
 require 'git'
+require 'octokit'
 
 module Dev
   # Class for performing git functions
@@ -408,7 +409,10 @@ module Dev
     # Clones the repo_name into the dir
     # Optionally specify a repo_org
     # Optionally specify a branch to check out (defaults to the repository default branch)
-    def clone_repo(dir:, repo_name:, repo_org: 'firespring', branch: nil, depth: nil)
+    def clone_repo(dir:, repo_name:, repo_org: nil, branch: nil, depth: nil)
+      # TODO: Split out the default of 'firespring' into a configuration variable
+      repo_org = 'firespring' if repo_org.to_s.strip.empty?
+
       if Dir.exist?("#{dir}/.git")
         puts "#{dir} already cloned".light_green
         return
@@ -425,6 +429,19 @@ module Dev
       g.fetch('origin', prune: true)
     end
 
+    def commit_status(token:, repo_name:, commit_id:, status:, repo_org: nil, options: {})
+      # TODO: Split out the default of 'firespring' into a configuration variable
+      repo_org = 'firespring' if repo_org.to_s.strip.empty?
+      repo = "#{repo_org}/#{repo_name}"
+
+      # Set up the GitHub client
+      client = Octokit::Client.new(access_token: token)
+
+      # Create the commit status
+      puts "Tagging commit #{commit_id} in #{repo} as #{status} for #{options[:context]}"
+      client.create_status(repo, commit_id, status, options)
+    end
+
     # Builds an ssh repo URL using the org and repo name given
     def ssh_repo_url(name, org)
       "git@github.com:#{org}/#{name}.git"

data/lib/firespring_dev_commands/templates/aws/services/route53.rb

@@ -6,16 +6,21 @@ module Dev
       module Services
         # Class contains rake templates for managing your AWS settings and logging in
         class Route53 < Dev::Template::BaseInterface
-          # Create the rake task which ensures active credentials are present
-          def create_ensure_credentials_task!
+          def create_list_zone_details_task!
             # Have to set a local variable to be accessible inside of the instance_eval block
             exclude = @exclude
 
             DEV_COMMANDS_TOP_LEVEL.instance_eval do
-              return if exclude.include?(:ensure_aws_credentials)
+              return if exclude.include?(:list_details)
 
-              task ensure_aws_credentials: %w(init) do
-                raise 'AWS Credentials not found / expired' unless Dev::Aws::Credentials.new.active?
+              namespace :aws do
+                namespace :hosted_zone do
+                  desc 'print details for all hosted zones'
+                  task list_details: %w(ensure_aws_credentials) do
+                    route53 = Dev::Aws::Route53.new(ENV['DOMAINS'].to_s.strip.split(','))
+                    route53.list_zone_details
+                  end
+                end
               end
             end
           end
@@ -26,9 +31,9 @@ module Dev
             exclude = @exclude
 
             DEV_COMMANDS_TOP_LEVEL.instance_eval do
-              namespace :aws do
-                return if exclude.include?(:dns_logging)
+              return if exclude.include?(:dns_logging_activate)
 
+              namespace :aws do
                 namespace :hosted_zone do
                   namespace :dns_logging do
                     desc 'Activates query logging for all hosted zones by default.' \
@@ -56,9 +61,9 @@ module Dev
             exclude = @exclude
 
             DEV_COMMANDS_TOP_LEVEL.instance_eval do
-              namespace :aws do
-                return if exclude.include?(:dns_logging)
+              return if exclude.include?(:dns_logging_deactivate)
 
+              namespace :aws do
                 namespace :hosted_zone do
                   namespace :dns_logging do
                     desc 'Deactivates query logging for all hosted zones by default. ' \
@@ -81,9 +86,9 @@ module Dev
             exclude = @exclude
 
             DEV_COMMANDS_TOP_LEVEL.instance_eval do
-              namespace :aws do
-                return if exclude.include?(:dns_logging)
+              return if exclude.include?(:dns_logging_config)
 
+              namespace :aws do
                 namespace :hosted_zone do
                   namespace :dns_logging do
                     desc 'Lists the current config for domain(s). ' \

data/lib/firespring_dev_commands/templates/git.rb

@@ -159,6 +159,154 @@ module Dev
           end
         end
       end
+
+      # Create the rake task for the git commit status pending task.
+      def create_commit_status_pending_task!
+        # Have to set a local variable to be accessible inside of the instance_eval block
+        exclude = @exclude
+
+        DEV_COMMANDS_TOP_LEVEL.instance_eval do
+          namespace :git do
+            return if exclude.include?(:commit_status)
+
+            namespace :commit_status do
+              desc 'Add pending status to commit' \
+                   "\n\tuse GITHUB_TOKEN=abc123 enables write options for the check (required)" \
+                   "\n\tuse REPOSITORY=abc123 to specify the repository (required)" \
+                   "\n\tuse COMMIT_ID=abc123 to specify the commit id of code (required)" \
+                   "\n\tuse CONTEXT=abc123 names the check on the PR (optional)" \
+                   "\n\tuse TARGET_URL={url} adds 'detail' hyperlink to check on the PR (optional)"
+              task :pending do
+                status = 'pending'
+                token = ENV['GITHUB_TOKEN'].to_s.strip
+                repo_org, repo_name = ENV['REPOSITORY'].to_s.strip.split('/')
+                commit_id = ENV['COMMIT_ID'].to_s.strip
+
+                raise 'GITHUB_TOKEN is required' unless token
+                raise 'REPOSITORY is required' unless repo_name
+                raise 'COMMIT_ID is required' unless commit_id
+
+                options = {}
+                options[:context] = ENV['CONTEXT'].to_s.strip unless ENV['CONTEXT'].to_s.strip.empty?
+                options[:target_url] = ENV['TARGET_URL'].to_s.strip unless ENV['TARGET_URL'].to_s.strip.empty?
+
+                Dev::Git.new.commit_status(token:, repo_name:, commit_id:, status:, repo_org:, options:)
+              end
+            end
+          end
+        end
+      end
+
+      # Create the rake task for the git commit status success task.
+      def create_commit_status_success_task!
+        # Have to set a local variable to be accessible inside of the instance_eval block
+        exclude = @exclude
+
+        DEV_COMMANDS_TOP_LEVEL.instance_eval do
+          namespace :git do
+            return if exclude.include?(:commit_status)
+
+            namespace :commit_status do
+              desc 'Add success status to commit' \
+                   "\n\tuse GITHUB_TOKEN=abc123 enables write options for the check (required)" \
+                   "\n\tuse REPOSITORY=abc123 to specify the repository (required)" \
+                   "\n\tuse COMMIT_ID=abc123 to specify the commit id of code (required)" \
+                   "\n\tuse CONTEXT=abc123 names the check on the PR (optional)" \
+                   "\n\tuse TARGET_URL={url} adds 'detail' hyperlink to check on the PR (optional)"
+              task :success do
+                status = 'success'
+                token = ENV['GITHUB_TOKEN'].to_s.strip
+                repo_org, repo_name = ENV['REPOSITORY'].to_s.strip.split('/')
+                commit_id = ENV['COMMIT_ID'].to_s.strip
+
+                raise 'GITHUB_TOKEN is required' unless token
+                raise 'REPOSITORY is required' unless repo_name
+                raise 'COMMIT_ID is required' unless commit_id
+
+                options = {}
+                options[:context] = ENV['CONTEXT'].to_s.strip unless ENV['CONTEXT'].to_s.strip.empty?
+                options[:target_url] = ENV['TARGET_URL'].to_s.strip unless ENV['TARGET_URL'].to_s.strip.empty?
+
+                Dev::Git.new.commit_status(token:, repo_name:, commit_id:, status:, repo_org:, options:)
+              end
+            end
+          end
+        end
+      end
+
+      # Create the rake task for the git commit status error task.
+      def create_commit_status_error_task!
+        # Have to set a local variable to be accessible inside of the instance_eval block
+        exclude = @exclude
+
+        DEV_COMMANDS_TOP_LEVEL.instance_eval do
+          namespace :git do
+            return if exclude.include?(:commit_status)
+
+            namespace :commit_status do
+              desc 'Add error status to commit' \
+                   "\n\tuse GITHUB_TOKEN=abc123 enables write options for the check (required)" \
+                   "\n\tuse REPOSITORY=abc123 to specify the repository (required)" \
+                   "\n\tuse COMMIT_ID=abc123 to specify the commit id of code (required)" \
+                   "\n\tuse CONTEXT=abc123 names the check on the PR (optional)" \
+                   "\n\tuse TARGET_URL={url} adds 'detail' hyperlink to check on the PR (optional)"
+              task :error do
+                status = 'error'
+                token = ENV['GITHUB_TOKEN'].to_s.strip
+                repo_org, repo_name = ENV['REPOSITORY'].to_s.strip.split('/')
+                commit_id = ENV['COMMIT_ID'].to_s.strip
+
+                raise 'GITHUB_TOKEN is required' unless token
+                raise 'REPOSITORY is required' unless repo_name
+                raise 'COMMIT_ID is required' unless commit_id
+
+                options = {}
+                options[:context] = ENV['CONTEXT'].to_s.strip unless ENV['CONTEXT'].to_s.strip.empty?
+                options[:target_url] = ENV['TARGET_URL'].to_s.strip unless ENV['TARGET_URL'].to_s.strip.empty?
+
+                Dev::Git.new.commit_status(token:, repo_name:, commit_id:, status:, repo_org:, options:)
+              end
+            end
+          end
+        end
+      end
+
+      # Create the rake task for the git commit status failure task.
+      def create_commit_status_failure_task!
+        # Have to set a local variable to be accessible inside of the instance_eval block
+        exclude = @exclude
+
+        DEV_COMMANDS_TOP_LEVEL.instance_eval do
+          namespace :git do
+            return if exclude.include?(:commit_status)
+
+            namespace :commit_status do
+              desc 'Add failure status to commit' \
+                   "\n\tuse GITHUB_TOKEN=abc123 enables write options for the check (required)" \
+                   "\n\tuse REPOSITORY=abc123 to specify the repository (required)" \
+                   "\n\tuse COMMIT_ID=abc123 to specify the commit id of code (required)" \
+                   "\n\tuse CONTEXT=abc123 names the check on the PR (optional)" \
+                   "\n\tuse TARGET_URL={url} adds 'detail' hyperlink to check on the PR (optional)"
+              task :failure do
+                status = 'failure'
+                token = ENV['GITHUB_TOKEN'].to_s.strip
+                repo_org, repo_name = ENV['REPOSITORY'].to_s.strip.split('/')
+                commit_id = ENV['COMMIT_ID'].to_s.strip
+
+                raise 'GITHUB_TOKEN is required' unless token
+                raise 'REPOSITORY is required' unless repo_name
+                raise 'COMMIT_ID is required' unless commit_id
+
+                options = {}
+                options[:context] = ENV['CONTEXT'].to_s.strip unless ENV['CONTEXT'].to_s.strip.empty?
+                options[:target_url] = ENV['TARGET_URL'].to_s.strip unless ENV['TARGET_URL'].to_s.strip.empty?
+
+                Dev::Git.new.commit_status(token:, repo_name:, commit_id:, status:, repo_org:, options:)
+              end
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/firespring_dev_commands/version.rb

@@ -6,6 +6,6 @@ module Dev
     # Use 'v.v.v.pre.alpha.v' for pre-release vesions
     # Use 'v.v.v.beta.v for beta versions
     # Use semantic versioning for any releases (https://semver.org/)
-    VERSION = '3.1.4.pre.alpha.2'.freeze
+    VERSION = '3.1.4'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: firespring_dev_commands
 version: !ruby/object:Gem::Version
-  version: 3.1.4.pre.alpha.2
+  version: 3.1.4
 platform: ruby
 authors:
 - Firespring
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-09 00:00:00.000000000 Z
+date: 2024-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -234,6 +234,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.110.0
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: git
   requirement: !ruby/object:Gem::Requirement
@@ -276,6 +290,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: octokit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
 - !ruby/object:Gem::Dependency
   name: ox
   requirement: !ruby/object:Gem::Requirement
@@ -367,6 +395,7 @@ files:
 - lib/firespring_dev_commands/coverage/cobertura.rb
 - lib/firespring_dev_commands/coverage/none.rb
 - lib/firespring_dev_commands/daterange.rb
+- lib/firespring_dev_commands/dns/resource.rb
 - lib/firespring_dev_commands/docker.rb
 - lib/firespring_dev_commands/docker/artifact.rb
 - lib/firespring_dev_commands/docker/compose.rb
@@ -447,9 +476,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.4.10
 signing_key: