dnsmadeeasy 0.4.0 → 1.0.3

data/lib/dnsmadeeasy/cli/commands/base.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'awesome_print'
+require 'json'
+require 'yaml'
+require 'dnsmadeeasy/cli/message_helpers'
+
+module DnsMadeEasy
+  module CLI
+    module Commands
+      # Base class for dry-cli commands.
+      class Base < Dry::CLI::Command
+        include MessageHelpers
+
+        SUPPORTED_FORMATS = %w[json json_pretty yaml pp].freeze
+        DEFAULT_CREDENTIAL_PATHS = [
+          Pathname.new('~/.dnsmadeeasy/credentials.ini').expand_path,
+          Pathname.new('./.dnsmadeeasy/credential.ini').expand_path
+        ].freeze
+
+        option :format, values: SUPPORTED_FORMATS, required: false, desc: 'Output format'
+        option :credentials, required: false, desc: 'Path to credentials INI file'
+        option :api_key, required: false, desc: 'DNS Made Easy API key'
+        option :api_secret, required: false, desc: 'DNS Made Easy API secret'
+
+        private
+
+        def puts(*)
+          @out.puts(*)
+        end
+
+        def warn(*)
+          @err.puts(*)
+        end
+
+        def print_formatted(result, format = nil)
+          case format&.to_sym
+          when :json
+            puts JSON.generate(result)
+          when :json_pretty
+            puts JSON.pretty_generate(result)
+          when :yaml
+            puts result.to_yaml
+          when :pp
+            require 'pp'
+            puts PP.pp(result, +'')
+          else
+            @out.puts(result.ai(indent: 10))
+          end
+        end
+
+        def configure_authentication(credentials: nil, api_key: nil, api_secret: nil)
+          resolved_api_key, resolved_api_secret = resolve_credentials(
+            credentials: credentials,
+            api_key: api_key,
+            api_secret: api_secret
+          )
+
+          DnsMadeEasy.api_key = resolved_api_key
+          DnsMadeEasy.api_secret = resolved_api_secret
+        end
+
+        def resolve_credentials(credentials: nil, api_key: nil, api_secret: nil)
+          return explicit_api_credentials(api_key, api_secret) if api_key || api_secret
+          return credentials_from_ini(Pathname.new(credentials).expand_path) if credentials
+          return [ENV.fetch('DNSMADEEASY_API_KEY'), ENV.fetch('DNSMADEEASY_API_SECRET')] if env_credentials?
+
+          default_credentials_path = DEFAULT_CREDENTIAL_PATHS.find(&:exist?)
+          return credentials_from_ini(default_credentials_path) if default_credentials_path
+
+          raise DnsMadeEasy::APIKeyAndSecretMissingError, 'DNS Made Easy credentials were not found'
+        end
+
+        def explicit_api_credentials(api_key, api_secret)
+          raise DnsMadeEasy::APIKeyAndSecretMissingError, '--api-key and --api-secret must be provided together' unless api_key && api_secret
+
+          [api_key, api_secret]
+        end
+
+        def env_credentials?
+          ENV.fetch('DNSMADEEASY_API_KEY', nil) && ENV.fetch('DNSMADEEASY_API_SECRET', nil)
+        end
+
+        def credentials_from_ini(path)
+          raise DnsMadeEasy::APIKeyAndSecretMissingError, "Credentials file #{path} does not exist" unless path.exist?
+
+          credentials = parse_ini_credentials(path)
+          api_key = credentials['api_key'] || credentials['dns_dnsmadeeasy_api_key']
+          api_secret = credentials['api_secret'] || credentials['dns_dnsmadeeasy_secret_key']
+          explicit_api_credentials(api_key, api_secret)
+        end
+
+        def parse_ini_credentials(path)
+          path.each_line.with_object({}) do |line, credentials|
+            key, value = parse_ini_line(line)
+            credentials[key] = value if key && value
+          end
+        end
+
+        def parse_ini_line(line)
+          stripped_line = line.strip
+          return nil if ignored_ini_line?(stripped_line)
+
+          key, value = stripped_line.split('=', 2).map(&:strip)
+          [key, unquote_ini_value(value)]
+        end
+
+        def ignored_ini_line?(stripped_line)
+          stripped_line.empty? || stripped_line.start_with?('#', ';', '[')
+        end
+
+        def unquote_ini_value(value)
+          value&.delete_prefix('"')&.delete_suffix('"')
+        end
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/cli/commands/legacy_operation.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'dnsmadeeasy/api/client'
+require 'dnsmadeeasy/cli/commands/base'
+
+module DnsMadeEasy
+  module CLI
+    # Registered dry-cli command classes.
+    module Commands
+      # Provides a migration hint for pre-1.0 root-level API operations.
+      class LegacyOperation < Base
+        desc 'Show migration hint for legacy root-level API operation'
+
+        def initialize(operation_name)
+          super()
+          @operation_name = operation_name
+        end
+
+        def call(**)
+          warn "Use `dme account #{@operation_name}` for this API operation."
+          raise ArgumentError, "legacy root operation #{@operation_name.inspect} moved under account"
+        end
+      end
+
+      DnsMadeEasy::Api::Client.public_operations.each do |operation_name|
+        register operation_name, LegacyOperation.new(operation_name), hidden: true
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/cli/commands/version.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'dnsmadeeasy/version'
+require 'dnsmadeeasy/cli/commands/base'
+
+module DnsMadeEasy
+  module CLI
+    # Registered dry-cli command classes.
+    module Commands
+      # Prints the gem version.
+      class Version < Base
+        desc 'Print version'
+
+        def call(*)
+          puts DnsMadeEasy::VERSION
+        end
+      end
+
+      register 'version', Version, aliases: %w[v -v --version]
+    end
+  end
+end

data/lib/dnsmadeeasy/cli/commands/zone.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+require 'dnsmadeeasy/cli/commands/base'
+require 'dnsmadeeasy/cli/input'
+require 'dnsmadeeasy/cli/message_helpers'
+require 'dnsmadeeasy/zone/aname_flattener'
+require 'dnsmadeeasy/zone/apply_executor'
+require 'dnsmadeeasy/zone/diff'
+require 'json'
+require 'dnsmadeeasy/zone/parser'
+require 'dnsmadeeasy/zone/plan_renderer'
+require 'dnsmadeeasy/zone/remote_adapter'
+require 'dnsmadeeasy/zone/serializer'
+require 'yaml'
+
+module DnsMadeEasy
+  module CLI
+    # Registered dry-cli command classes.
+    module Commands
+      # Zone-file management commands.
+      module Zone
+        # Shared handling for the `DOMAIN FILE` positional-argument pair used
+        # by the provider-facing commands (plan, apply). Reads the zone file
+        # with a friendly failure instead of a raw Errno::ENOENT, and verifies
+        # the file's $ORIGIN agrees with the domain argument BEFORE any API
+        # call is made — diffing foo.com against bar.com.zone should be an
+        # error, not a surprise apply. Comparison strips the RFC trailing dot
+        # ($ORIGIN is an FQDN like "kig.re.") and ignores case.
+        module DomainArguments
+          private
+
+          def read_zone_source!(file, domain:)
+            ::File.read(file)
+          rescue Errno::ENOENT, Errno::EISDIR
+            lines = ["Zone file not found: #{file}"]
+            lines << swap_hint if ::File.file?(domain.to_s)
+            error(lines.join("\n"))
+            raise ReportedError, 'zone file not found'
+          end
+
+          def ensure_origin_matches!(domain:, origin:)
+            return if origin.nil? || normalize_domain(origin) == normalize_domain(domain)
+
+            lines = [
+              'Domain and zone file disagree.',
+              kv('Domain argument', domain),
+              kv('Zone file $ORIGIN', origin)
+            ]
+            lines << swap_hint if ::File.file?(domain.to_s)
+            error(lines.join("\n"))
+            raise ReportedError, 'domain and zone file disagree'
+          end
+
+          def normalize_domain(name)
+            name.to_s.delete_suffix('.').downcase
+          end
+
+          def swap_hint
+            "It looks like the arguments are swapped. Usage: #{usage_hint}"
+          end
+        end
+
+        # Validates a standard DNS zone file.
+        class Validate < Base
+          desc 'Validate a DNS zone file'
+
+          argument :file, required: true, desc: 'Zone file path'
+
+          def call(file:, **)
+            result = DnsMadeEasy::Zone::Parser.new(::File.read(file)).call
+
+            if result.success?
+              record_count = result.value!.records.length
+              success("Zone file is valid.\n#{kv('Records', record_count)}")
+            else
+              warning("Zone file is invalid.\n#{result.failure.join("\n")}")
+              raise ReportedError, 'zone file is invalid'
+            end
+          end
+        end
+
+        # Formats a standard DNS zone file into canonical output.
+        class Format < Base
+          desc 'Format a DNS zone file'
+
+          argument :file, required: true, desc: 'Zone file path'
+
+          def call(file:, **)
+            result = DnsMadeEasy::Zone::Parser.new(::File.read(file)).call
+
+            if result.success?
+              puts DnsMadeEasy::Zone::Serializer.new(result.value!)
+              success("Zone file formatted.\n#{kv('Records', result.value!.records.length)}")
+            else
+              error("Zone file is invalid.\n#{result.failure.join("\n")}")
+              raise ReportedError, 'zone file is invalid'
+            end
+          end
+        end
+
+        # Exports DNS Made Easy records as canonical zone-file text.
+        class Export < Base
+          desc 'Export DNS Made Easy records as a canonical zone file'
+
+          argument :domain, required: true, desc: 'Domain name'
+
+          option :format, aliases: ['f'], values: %w[rfc json yaml], required: false,
+                          desc: 'Export format: rfc, json, or yaml'
+          option :output, required: false, desc: 'Output file path'
+          option :ttl, required: false, desc: 'Default TTL for records missing provider TTL'
+          option :include_apex_ns, type: :boolean, default: false, desc: 'Include apex NS records'
+          option :strict_rfc, type: :boolean, default: false,
+                              desc: 'Flatten ANAME records into resolved A records (RFC-portable output)'
+
+          def call(**options)
+            configure_authentication(credentials: options[:credentials], api_key: options[:api_key],
+                                     api_secret: options[:api_secret])
+
+            domain = options.fetch(:domain)
+            export_ttl = options[:ttl] || 300
+            result = DnsMadeEasy::Zone::RemoteAdapter.new(
+              DnsMadeEasy.client.records_for(domain),
+              domain: domain,
+              default_ttl: export_ttl
+            ).call
+            fail_export(result.failure) if result.failure?
+
+            records_result = export_ready_records(result.value!, strict_rfc: options[:strict_rfc])
+            fail_export(records_result.failure) if records_result.failure?
+
+            records, warnings = records_result.value!
+            export_records(
+              domain,
+              records,
+              warnings: warnings,
+              format: options[:format] || 'rfc',
+              output: options[:output],
+              ttl: export_ttl,
+              include_apex_ns: options[:include_apex_ns]
+            )
+            success(
+              [
+                'Zone export complete.',
+                kv('Domain', domain),
+                kv('Records', records.length),
+                kv('Destination', options[:output] || 'STDOUT')
+              ].join("\n")
+            )
+          end
+
+          private
+
+          def fail_export(errors)
+            error("Zone export failed.\n#{errors.join("\n")}")
+            raise ReportedError, 'zone export failed'
+          end
+
+          def export_ready_records(remote_records, strict_rfc:)
+            return Dry::Monads::Success([remote_records.records, remote_records.warnings]) unless strict_rfc
+
+            DnsMadeEasy::Zone::AnameFlattener.new(remote_records.records).call.fmap do |(records, notices)|
+              [records, remote_records.warnings + notices]
+            end
+          end
+
+          def export_records(domain, records, warnings:, format:, output:, ttl:, include_apex_ns:)
+            warnings.each { |warning| warn warning }
+            zone_text = export_text(domain, records, format: format, ttl: ttl, include_apex_ns: include_apex_ns)
+
+            output ? ::File.write(output, zone_text) : puts(zone_text)
+          end
+
+          def export_text(domain, records, format:, ttl:, include_apex_ns:)
+            zone_file = zone_file(domain, records, ttl: ttl)
+
+            case format
+            when 'json'
+              JSON.pretty_generate(export_hash(zone_file))
+            when 'yaml'
+              export_hash(zone_file).to_yaml
+            else
+              DnsMadeEasy::Zone::Serializer.new(zone_file, omit_apex_ns: !include_apex_ns).to_s
+            end
+          end
+
+          def zone_file(domain, records, ttl:)
+            DnsMadeEasy::Zone::File.new(
+              origin: "#{domain.delete_suffix('.')}.",
+              ttl: dominant_ttl(records, fallback: ttl),
+              record_set: DnsMadeEasy::Zone::RecordSet.new(records: records)
+            )
+          end
+
+          # $TTL is the most common record TTL so the export stays faithful
+          # while keeping explicit per-record TTLs to a minimum.
+          def dominant_ttl(records, fallback:)
+            records.map(&:ttl).tally.max_by { |ttl, count| [count, -ttl] }&.first || fallback
+          end
+
+          def export_hash(zone_file)
+            {
+              'origin' => zone_file.origin,
+              'ttl' => zone_file.ttl,
+              'records' => zone_file.sorted.map { |record| record_hash(record) }
+            }
+          end
+
+          def record_hash(record)
+            {
+              'owner' => record.owner,
+              'type' => record.type,
+              'value' => record.value,
+              'ttl' => record.ttl,
+              'priority' => record.priority,
+              'weight' => record.weight,
+              'port' => record.port
+            }.compact
+          end
+        end
+
+        # Produces a non-destructive plan comparing a zone file to remote records.
+        class Plan < Base
+          include DomainArguments
+
+          desc 'Plan DNS changes for a zone file'
+
+          argument :domain, required: true, desc: 'Domain name'
+          argument :file, required: true, desc: 'Zone file path'
+
+          option :format, values: %w[text json], default: 'text', required: false, desc: 'Plan output format'
+          option :diff_ttl, type: :boolean, default: false, desc: 'Treat TTL-only differences as updates'
+
+          def call(domain:, file:, format: 'text', diff_ttl: false, credentials: nil, api_key: nil, api_secret: nil, **)
+            configure_authentication(credentials: credentials, api_key: api_key, api_secret: api_secret)
+
+            desired_result = DnsMadeEasy::Zone::Parser.new(read_zone_source!(file, domain: domain)).call
+            return fail_with('Zone file is invalid', desired_result.failure) if desired_result.failure?
+
+            ensure_origin_matches!(domain: domain, origin: desired_result.value!.origin)
+
+            plan_domain = normalize_domain(domain)
+            remote_result = remote_records(plan_domain)
+            return fail_with('Remote records are invalid', remote_result.failure) if remote_result.failure?
+
+            plan = DnsMadeEasy::Zone::Diff.new(
+              desired_records: desired_result.value!.records,
+              remote_records: remote_result.value!.records,
+              compare_ttl: diff_ttl
+            ).call
+            renderer = DnsMadeEasy::Zone::PlanRenderer.new(plan)
+
+            puts(format == 'json' ? renderer.to_json : renderer.to_text)
+            success(plan_summary(plan_domain, plan))
+          end
+
+          private
+
+          def usage_hint
+            'dmez zone plan DOMAIN FILE'
+          end
+
+          def plan_summary(domain, plan)
+            [
+              "Zone plan complete for #{domain}.",
+              kv('Creates', plan.creates.length),
+              kv('Updates', plan.updates.length),
+              kv('Skipped creates', plan.skipped_creates.length),
+              kv('Skipped deletes', plan.skipped_deletes.length),
+              kv('Manual review', plan.ambiguous.length)
+            ].join("\n")
+          end
+
+          def remote_records(domain)
+            DnsMadeEasy::Zone::RemoteAdapter.new(DnsMadeEasy.client.records_for(domain), domain: domain).call
+          end
+
+          def fail_with(message, errors)
+            error("#{message}.\n#{errors.join("\n")}")
+            raise ReportedError, message.downcase
+          end
+        end
+
+        # Applies a reviewed zone plan safely.
+        class Apply < Base
+          include DomainArguments
+
+          desc 'Apply DNS changes for a zone file'
+
+          argument :domain, required: true, desc: 'Domain name'
+          argument :file, required: true, desc: 'Zone file path'
+
+          option :yes, aliases: ['y'], type: :boolean, default: false, desc: 'Apply without confirmation prompt'
+          option :add_only, aliases: ['a'], type: :boolean, default: false, desc: 'Only add missing records'
+          option :delete_only, aliases: ['d'], type: :boolean, default: false, desc: 'Only apply deletions'
+          option :merge, aliases: ['m'], type: :boolean, default: true, desc: 'Merge creates and updates'
+          option :diff_ttl, type: :boolean, default: false, desc: 'Treat TTL-only differences as updates'
+
+          def call(**options)
+            configure_authentication(credentials: options[:credentials], api_key: options[:api_key],
+                                     api_secret: options[:api_secret])
+
+            plan_context = build_plan_context(options.fetch(:domain), options.fetch(:file),
+                                              compare_ttl: options[:diff_ttl])
+            return fail_with('Zone apply failed', plan_context.failure) if plan_context.failure?
+
+            mode = apply_mode(options)
+            executor = DnsMadeEasy::Zone::ApplyExecutor.new(
+              client: DnsMadeEasy.client,
+              domain: plan_context.value!.fetch(:domain),
+              plan: plan_context.value!.fetch(:plan),
+              remote_records: plan_context.value!.fetch(:remote_records),
+              mode: mode,
+              spinner_output: @err
+            )
+            executable_count = executor.executable_action_count
+            confirm!(executable_count) unless options[:yes]
+
+            result = executor.call
+            return fail_with('Zone apply failed', result.failure) if result.failure?
+
+            print_apply_summary(plan_context.value!.fetch(:domain), result.value!)
+          end
+
+          private
+
+          def build_plan_context(domain, file, compare_ttl: false)
+            desired_result = DnsMadeEasy::Zone::Parser.new(read_zone_source!(file, domain: domain)).call
+            return desired_result if desired_result.failure?
+
+            ensure_origin_matches!(domain: domain, origin: desired_result.value!.origin)
+
+            plan_domain = normalize_domain(domain)
+            remote_result = DnsMadeEasy::Zone::RemoteAdapter.new(DnsMadeEasy.client.records_for(plan_domain),
+                                                                 domain: plan_domain).call
+            return remote_result if remote_result.failure?
+
+            plan = DnsMadeEasy::Zone::Diff.new(
+              desired_records: desired_result.value!.records,
+              remote_records: remote_result.value!.records,
+              compare_ttl: compare_ttl
+            ).call
+
+            Dry::Monads::Success(domain: plan_domain, plan: plan, remote_records: remote_result.value!)
+          end
+
+          def usage_hint
+            'dmez zone apply DOMAIN FILE'
+          end
+
+          def apply_mode(options)
+            return :add_only if options[:add_only]
+            return :delete_only if options[:delete_only]
+
+            :merge
+          end
+
+          def confirm!(executable_count)
+            warn "Apply #{executable_count} action(s)? Type yes to continue:"
+            response = DnsMadeEasy::CLI::Input.stdin.gets.to_s.strip
+            return if response == 'yes'
+
+            raise ArgumentError, 'zone apply cancelled'
+          end
+
+          def print_apply_summary(domain, result)
+            summary = [
+              "Zone apply complete for #{domain}.",
+              kv('Applied', result.applied_actions.length),
+              kv('Failed', result.failed_actions.length),
+              kv('Skipped', result.skipped_actions.length)
+            ].join("\n")
+
+            result.failed_actions.empty? ? success(summary) : warning(summary)
+          end
+
+          def fail_with(message, errors)
+            error("#{message}.\n#{errors.join("\n")}")
+            raise ReportedError, message.downcase
+          end
+        end
+      end
+
+      register 'zone' do |prefix|
+        prefix.register 'validate', Zone::Validate
+        prefix.register 'fmt', Zone::Format, aliases: ['format']
+        prefix.register 'export', Zone::Export
+        prefix.register 'plan', Zone::Plan
+        prefix.register 'apply', Zone::Apply
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/cli/commands.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+
+module DnsMadeEasy
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+    end
+  end
+end
+
+require 'dnsmadeeasy/cli/message_helpers'
+require 'dnsmadeeasy/cli/reported_error'
+require 'dnsmadeeasy/cli/commands/base'
+require 'dnsmadeeasy/cli/commands/version'
+require 'dnsmadeeasy/cli/commands/account'
+require 'dnsmadeeasy/cli/commands/zone'
+require 'dnsmadeeasy/cli/commands/legacy_operation'

data/lib/dnsmadeeasy/cli/input.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DnsMadeEasy
+  module CLI
+    # Shared input stream for commands that need confirmation.
+    module Input
+      class << self
+        attr_accessor :stdin
+      end
+
+      self.stdin = $stdin
+    end
+  end
+end

data/lib/dnsmadeeasy/cli/launcher.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'dnsmadeeasy/version'
+require 'dnsmadeeasy/cli/commands'
+require 'dnsmadeeasy/cli/input'
+
+module DnsMadeEasy
+  module CLI
+    # Entrypoint used by the executable and in-process CLI specs.
+    class Launcher
+      attr_reader :argv, :stdin, :stdout, :stderr, :kernel
+
+      def initialize(argv, stdin = $stdin, stdout = $stdout, stderr = $stderr, kernel = Kernel)
+        @argv = argv
+        @stdin = stdin
+        @stdout = stdout
+        @stderr = stderr
+        @kernel = kernel
+      end
+
+      def execute!
+        return print_account_operation_help if account_operation_help?
+
+        Input.stdin = stdin
+        command.call(arguments: argv, out: stdout, err: stderr)
+        0
+      rescue SystemExit => e
+        e.status
+      rescue ReportedError
+        1
+      rescue StandardError => e
+        stderr.puts(e.message)
+        1
+      end
+
+      private
+
+      def account_operation_help?
+        argv.first == 'account' && argv[1] && !argv[1].start_with?('-') && argv.intersect?(%w[--help -h])
+      end
+
+      def print_account_operation_help
+        stdout.puts Commands::Account.operation_help(argv[1])
+        0
+      end
+
+      def command
+        @command ||= Dry::CLI.new(Commands)
+      end
+    end
+  end
+end