vagrant-docker-hosts-manager 0.3.0 → 0.4.0

data/lib/vagrant-docker-hosts-manager/config.rb

@@ -1,6 +1,18 @@
 # frozen_string_literal: true
 
 module VagrantDockerHostsManager
+  # Vagrant configuration for managed host entries.
+  #
+  # @!attribute domains
+  #   @return [Hash{String=>String}] Mapping of domain names to IP addresses.
+  # @!attribute domain
+  #   @return [String, nil] Single domain to resolve from `ip` or `container_name`.
+  # @!attribute container_name
+  #   @return [String, nil] Docker container used for automatic IP discovery.
+  # @!attribute ip
+  #   @return [String, nil] Static IPv4 address for `domain`.
+  # @!attribute locale
+  #   @return [String, nil] Optional locale code.
   class Config < Vagrant.plugin("2", :config)
     attr_accessor :domains
     attr_accessor :domain
@@ -10,19 +22,28 @@ module VagrantDockerHostsManager
     attr_accessor :verbose
 
     def initialize
-      @domains        = {}
-      @domain         = nil
-      @container_name = nil
-      @ip             = nil
-      @locale         = nil
-      @verbose        = false
+      @domains        = UNSET_VALUE
+      @domain         = UNSET_VALUE
+      @container_name = UNSET_VALUE
+      @ip             = UNSET_VALUE
+      @locale         = UNSET_VALUE
+      @verbose        = UNSET_VALUE
     end
 
-    def finalize!; end
+    def finalize!
+      @domains        = {}    if @domains == UNSET_VALUE
+      @domain         = nil   if @domain == UNSET_VALUE
+      @container_name = nil   if @container_name == UNSET_VALUE
+      @ip             = nil   if @ip == UNSET_VALUE
+      @locale         = nil   if @locale == UNSET_VALUE
+      @verbose        = false if @verbose == UNSET_VALUE
+    end
 
     def validate(_machine)
       errors = []
 
+      return { "vagrant-docker-hosts-manager" => errors } unless configured?
+
       if (@domains.nil? || @domains.empty?) && (@domain.nil? || @domain.strip.empty?)
         errors << "You must configure at least one domain: " \
                   "`config.docker_hosts.domain = \"example.test\"` or set " \
@@ -43,5 +64,16 @@ module VagrantDockerHostsManager
 
       { "vagrant-docker-hosts-manager" => errors }
     end
+
+    private
+
+    def configured?
+      (@domains.is_a?(Hash) && !@domains.empty?) ||
+        present?(@domain) || present?(@container_name) || present?(@ip)
+    end
+
+    def present?(value)
+      !value.nil? && !value.to_s.strip.empty?
+    end
   end
 end

data/lib/vagrant-docker-hosts-manager/helpers.rb

@@ -9,6 +9,7 @@ module VagrantDockerHostsManager
 
     SUPPORTED      = [:en, :fr].freeze
     OUR_NAMESPACES = %w[messages. errors. log. help.].freeze
+    NS             = "vdhm"
 
     EMOJI = {
       success:  "✅",
@@ -31,6 +32,9 @@ module VagrantDockerHostsManager
 
       base  = File.expand_path("../../locales", __dir__)
       paths = Dir[File.join(base, "*.yml")]
+      if paths.empty? && File.directory?(base)
+        paths = Dir.children(base).grep(/\.ya?ml\z/).map { |file| File.join(base, file) }
+      end
       ::I18n.load_path |= paths
       ::I18n.available_locales = SUPPORTED
 
@@ -60,22 +64,28 @@ module VagrantDockerHostsManager
       set_locale!("en")
     end
 
+    def namespaced(key)
+      k = key.to_s
+      k.start_with?("#{NS}.") ? k : "#{NS}.#{k}"
+    end
+
     def t(key, **opts)
-      ::I18n.t(key, **opts)
+      setup_i18n!
+      ::I18n.t(namespaced(key), **opts)
     end
 
     def t!(key, **opts)
       setup_i18n!
-      k = key.to_s
-      if our_key?(k) && !::I18n.exists?(k, ::I18n.locale)
-        raise MissingTranslationError, "#{EMOJI[:error]} [#{::I18n.locale}] Missing translation for key: #{k}"
+      nk = namespaced(key)
+      if our_key?(key.to_s) && !::I18n.exists?(nk, ::I18n.locale)
+        raise MissingTranslationError, "#{EMOJI[:error]} [#{::I18n.locale}] Missing translation for key: #{nk}"
       end
-      ::I18n.t(k, **opts)
+      ::I18n.t(nk, **opts)
     end
 
     def t_hash(key)
       setup_i18n!
-      v = ::I18n.t(key, default: {})
+      v = ::I18n.t(namespaced(key), default: {})
       v.is_a?(Hash) ? v : {}
     end
 

data/lib/vagrant-docker-hosts-manager/plugin.rb

@@ -11,6 +11,8 @@ require_relative "util/hosts_file"
 require_relative "util/docker"
 require_relative "util/json"
 require_relative "util/i18n"
+require_relative "actions/apply"
+require_relative "actions/cleanup"
 
 begin
   I18n.enforce_available_locales = false
@@ -47,94 +49,4 @@ module VagrantDockerHostsManager
       hook.prepend(Action::Cleanup)
     end
   end
-
-  module Action
-    class Apply
-      def initialize(app, env) = (@app = app)
-
-      def call(env)
-        Util::I18n.setup!(env)
-        cfg    = env[:machine].config.docker_hosts
-        mid    = env[:machine].id || "unknown"
-        dry    = Util::I18n.env_flag("VDHM_DRY_RUN")
-        ui     = env[:ui]
-        hoster = Util::HostsFile.new(env, owner_id: mid)
-
-        entries = compute_entries(env, cfg, ui)
-        if entries.empty?
-          UiHelpers.say(ui, ::I18n.t("messages.no_entries"))
-          return
-        end
-
-        if dry
-          Util::Json.emit(action: "apply", status: "dry-run", data: { owner: mid, entries: entries })
-          return
-        end
-
-        hoster.apply(entries)
-        Util::Json.emit(action: "apply", status: "success", data: { owner: mid, entries: entries })
-      rescue StandardError => e
-        Util::Json.emit(action: "apply", status: "error", error: e.message, backtrace: e.backtrace&.first(3))
-        UiHelpers.error(ui, "VDHM: #{e.message}")
-      ensure
-        @app.call(env)
-      end
-
-      private
-
-      def compute_entries(env, cfg, ui)
-        entries = {}
-
-        cfg.domains.each do |domain, ip|
-          next if domain.to_s.strip.empty?
-          if ip.nil? || ip.to_s.strip.empty?
-            UiHelpers.warn(ui, ::I18n.t("messages.missing_ip_for", domain: domain))
-            next
-          end
-          entries[domain] = ip
-        end
-
-        if cfg.domain && !cfg.domain.strip.empty?
-          ip = cfg.ip || begin
-            if cfg.container_name && !cfg.container_name.strip.empty?
-              Util::Docker.ip_for_container(cfg.container_name)
-            end
-          end
-          if ip && !ip.strip.empty?
-            UiHelpers.say(ui, ::I18n.t("messages.detected_ip", domain: cfg.domain, ip: ip))
-            entries[cfg.domain] = ip
-          else
-            UiHelpers.warn(ui, ::I18n.t("messages.no_ip_found", domain: cfg.domain, container: cfg.container_name))
-          end
-        end
-
-        entries
-      end
-    end
-
-    class Cleanup
-      def initialize(app, env) = (@app = app)
-
-      def call(env)
-        Util::I18n.setup!(env)
-        mid    = env[:machine].id || "unknown"
-        dry    = Util::I18n.env_flag("VDHM_DRY_RUN")
-        ui     = env[:ui]
-        hoster = Util::HostsFile.new(env, owner_id: mid)
-
-        if dry
-          Util::Json.emit(action: "cleanup", status: "dry-run", data: { owner: mid })
-          return
-        end
-
-        removed = hoster.remove!
-        Util::Json.emit(action: "cleanup", status: "success", data: { owner: mid, removed: removed })
-      rescue StandardError => e
-        Util::Json.emit(action: "cleanup", status: "error", error: e.message)
-        UiHelpers.error(ui, "VDHM: #{e.message}")
-      ensure
-        @app.call(env)
-      end
-    end
-  end
 end

data/lib/vagrant-docker-hosts-manager/util/docker.rb

@@ -1,32 +1,28 @@
 # frozen_string_literal: true
 
 require "open3"
+require_relative "verbose"
 
 module VagrantDockerHostsManager
   module Util
     module Docker
       module_function
 
+      # Resolves the first IPv4 address exposed by Docker inspect for a container.
+      #
+      # @param name [String, #to_s] Docker container name or id.
+      # @return [String, nil] First IPv4 address, or nil when Docker cannot resolve it.
       def ip_for_container(name)
         return nil if name.to_s.strip.empty?
-        out, _err, status = Open3.capture3(
-          "docker", "inspect", "-f",
-          "{{range .NetworkSettings.Networks}}{{.IPAddress}} {{end}}",
-          name.to_s
-        )
+
+        fmt = "{{range .NetworkSettings.Networks}}{{.IPAddress}} {{end}}"
+        Verbose.log("docker", "inspect", "-f", fmt, name.to_s)
+        out, _err, status = Open3.capture3("docker", "inspect", "-f", fmt, name.to_s)
         return nil unless status.success?
         out.split(/\s+/).find { |ip| ip =~ /\A\d{1,3}(\.\d{1,3}){3}\z/ }
       rescue StandardError
         nil
       end
-
-      def shell_escape(str)
-        if Gem.win_platform?
-          %('#{str.to_s.gsub("'", "''")}')
-        else
-          %('#{str.to_s.gsub("'", "'\\''")}')
-        end
-      end
     end
   end
 end

data/lib/vagrant-docker-hosts-manager/util/hosts_file.rb

@@ -7,6 +7,7 @@ require "open3"
 
 require_relative "../helpers"
 require_relative "docker"
+require_relative "verbose"
 
 module VagrantDockerHostsManager
   module Util
@@ -16,6 +17,10 @@ module VagrantDockerHostsManager
       WIN_SYSNATIVE_PATH = "C:/Windows/Sysnative/drivers/etc/hosts"
       WIN_SYSWOW64_PATH  = "C:/Windows/SysWOW64/drivers/etc/hosts"
 
+      BLOCK_START_RE = /^\s*#\s*>>>\s*vagrant-docker-hosts-manager\s+(.+?)\s*\(managed\)\s*>>>\s*$/i
+      BLOCK_STOP_RE  = /^\s*#\s*<<<\s*vagrant-docker-hosts-manager\s+(.+?)\s*\(managed\)\s*<<<\s*$/i
+      ENTRY_RE       = /\A\s*(\d{1,3}(?:\.\d{1,3}){3})\s+([^\s#]+)/
+
       def initialize(env, owner_id:)
         @env      = env || {}
         @owner_id = owner_id.to_s
@@ -28,8 +33,13 @@ module VagrantDockerHostsManager
       end
 
       def path_candidates
-        return [POSIX_PATH] unless Gem.win_platform?
+        # VDHM_HOSTS_PATH overrides the default location on every platform
+        # (used by tests and power users); honor it before anything else.
         return [override_path] if override_path
+        return [POSIX_PATH] unless Gem.win_platform?
+
+        # Sysnative lets a 32-bit Ruby process reach the real System32 hosts
+        # file on 64-bit Windows; keep it before System32/SysWOW64.
         [WIN_SYSNATIVE_PATH, WIN_SYS32_PATH, WIN_SYSWOW64_PATH]
       end
 
@@ -103,11 +113,20 @@ module VagrantDockerHostsManager
         str.end_with?(nl) ? str : (str + nl)
       end
 
+      # Applies managed host entries to the hosts file.
+      #
+      # Rewrites only this plugin's managed block and preserves unmanaged lines.
+      # Entries are normalized and sorted so repeated runs converge to the same
+      # file content.
+      #
+      # @param entries [Hash{String=>String}] Mapping of FQDN to IP address.
+      # @return [Integer] Number of managed entries present after applying changes.
+      # @raise [RuntimeError] When elevated writes fail.
       def apply(entries)
         entries = normalize_entries(entries)
         if entries.empty?
           UiHelpers.say(@ui, "#{UiHelpers.e(:info)} " +
-            ::I18n.t("messages.no_entries", default: "No hosts entries configured."))
+            ::I18n.t("vdhm.messages.no_entries", default: "No hosts entries configured."))
           return 0
         end
 
@@ -137,7 +156,7 @@ module VagrantDockerHostsManager
 
         if added.empty? && updated.empty?
           UiHelpers.say(@ui, "#{UiHelpers.e(:info)} " +
-            ::I18n.t("messages.no_change", default: "Nothing to apply. Already up-to-date."))
+            ::I18n.t("vdhm.messages.no_change", default: "Nothing to apply. Already up-to-date."))
           return existing_map.size
         end
 
@@ -146,14 +165,21 @@ module VagrantDockerHostsManager
         write(content)
 
         UiHelpers.say(@ui, "#{UiHelpers.e(:success)} " +
-          ::I18n.t("messages.applied", default: "Hosts entries applied."))
+          ::I18n.t("vdhm.messages.applied", default: "Hosts entries applied."))
         UiHelpers.say(@ui, "#{UiHelpers.e(:info)} " +
-          ::I18n.t("messages.apply_summary",
+          ::I18n.t("vdhm.messages.apply_summary",
                   default: "Added: %{a}, Updated: %{u}, Unchanged: %{s}",
                   a: added.size, u: updated.size, s: unchanged.size))
         merged.size
       end
 
+      # Removes matching entries from the current owner's managed block.
+      #
+      # With no filters this falls back to removing the whole current-owner block.
+      #
+      # @param ips [Array<String>] IP addresses to remove.
+      # @param domains [Array<String>] Domain names to remove.
+      # @return [Integer] Number of removed entries, or 1 when a whole block was removed.
       def remove_entries!(ips: [], domains: [])
         ips     = Array(ips).map(&:to_s).reject(&:empty?)
         domains = Array(domains).map(&:to_s).reject(&:empty?)
@@ -170,7 +196,7 @@ module VagrantDockerHostsManager
         removed_count = before - filtered.length
         if removed_count <= 0
           UiHelpers.say(@ui, "#{UiHelpers.e(:info)} " +
-            ::I18n.t("messages.remove_none",
+            ::I18n.t("vdhm.messages.remove_none",
               default: "No matching entry to remove."))
           return 0
         end
@@ -192,7 +218,7 @@ module VagrantDockerHostsManager
           @ui,
           "#{UiHelpers.e(:broom)} " +
             ::I18n.t(
-              "messages.removed_count",
+              "vdhm.messages.removed_count",
               default: "%{count} entries removed.",
               count: removed_count
             )
@@ -200,6 +226,9 @@ module VagrantDockerHostsManager
         removed_count
       end
 
+      # Removes the current owner's managed hosts block.
+      #
+      # @return [Boolean] Whether a block was removed.
       def remove!
         content = read
         newc = remove_block_from(content)
@@ -207,12 +236,44 @@ module VagrantDockerHostsManager
         write(newc) if removed
 
         UiHelpers.say(@ui, removed ?
-          "#{UiHelpers.e(:broom)} " + ::I18n.t("messages.cleaned", default: "Managed hosts entries removed.") :
-          "#{UiHelpers.e(:info)} "  + ::I18n.t("messages.nothing_to_clean", default: "Nothing to clean."))
+          "#{UiHelpers.e(:broom)} " + ::I18n.t("vdhm.messages.cleaned", default: "Managed hosts entries removed.") :
+          "#{UiHelpers.e(:info)} "  + ::I18n.t("vdhm.messages.nothing_to_clean", default: "Nothing to clean."))
+        removed
+      end
+
+      # Removes every block managed by this plugin, regardless of owner.
+      #
+      # @return [Boolean] Whether any managed block was removed.
+      def remove_all_managed!
+        content = read
+        newc = strip_managed_blocks(content)
+        removed = (newc != content)
+        write(newc) if removed
+
+        UiHelpers.say(@ui, removed ?
+          "#{UiHelpers.e(:broom)} " + ::I18n.t("vdhm.messages.cleaned_all", default: "All managed hosts blocks removed.") :
+          "#{UiHelpers.e(:info)} "  + ::I18n.t("vdhm.messages.nothing_to_clean", default: "Nothing to clean."))
         removed
       end
 
+      def strip_managed_blocks(content)
+        removing = false
+        content.lines.reject do |line|
+          if line.match?(BLOCK_START_RE)
+            removing = true
+            true
+          elsif line.match?(BLOCK_STOP_RE)
+            removing = false
+            true
+          else
+            removing
+          end
+        end.join
+      end
+
       def read
+        # Hosts files are often edited by Windows tools with BOMs or legacy
+        # encodings; normalize to UTF-8 before parsing managed blocks.
         pth = real_path
         UiHelpers.debug(@ui, "read(#{pth})")
 
@@ -229,6 +290,7 @@ module VagrantDockerHostsManager
         if (data.nil? || data.empty?) && Gem.win_platform?
           ps_path = pth.gsub("'", "''")
           ps_cmd  = "Get-Content -LiteralPath '#{ps_path}' -Raw"
+          Verbose.log("powershell -Command #{ps_cmd}")
           out, err, st = Open3.capture3("powershell", "-NoProfile", "-NonInteractive", "-Command", ps_cmd)
           if st.success?
             data = out
@@ -275,29 +337,28 @@ module VagrantDockerHostsManager
         ""
       end
 
-      def list_pairs(scope = :all)
-        content = read
-        return [] if content.to_s.empty?
+      def each_managed_entry(scope = :all)
+        # A single scanner powers both current-owner and all-owner cleanup paths
+        # so marker parsing rules stay identical.
+        return enum_for(:each_managed_entry, scope) unless block_given?
 
-        start_re = /^\s*#\s*>>>\s*vagrant-docker-hosts-manager\s+(.+?)\s*\(managed\)\s*>>>\s*$/i
-        stop_re  = /^\s*#\s*<<<\s*vagrant-docker-hosts-manager\s+(.+?)\s*\(managed\)\s*<<<\s*$/i
-        ip_re    = /^\s*(\d{1,3}(?:\.\d{1,3}){3})\s+([^\s#]+)/
+        content = read
+        return if content.to_s.empty?
 
-        out      = []
         in_block = false
         owner    = nil
 
         content.each_line.with_index(1) do |raw, idx|
           line = raw.delete_suffix("\n").delete_suffix("\r")
 
-          if (m = line.match(start_re))
+          if (m = line.match(BLOCK_START_RE))
             in_block = true
             owner    = m[1].to_s.strip
             UiHelpers.debug(@ui, "start block(owner=#{owner}) at line #{idx}")
             next
           end
 
-          if (m = line.match(stop_re))
+          if line.match?(BLOCK_STOP_RE)
             UiHelpers.debug(@ui, "stop  block(owner=#{owner}) at line #{idx}") if in_block
             in_block = false
             owner    = nil
@@ -307,103 +368,25 @@ module VagrantDockerHostsManager
           next unless in_block
           next unless scope == :all || owner == @owner_id
 
-          if (m = line.match(ip_re))
-            ip, fqdn = m[1], m[2]
-            out << [ip, fqdn, owner]
-            UiHelpers.debug(@ui, "  ip line: #{ip} #{fqdn} (owner=#{owner})")
+          if (m = line.match(ENTRY_RE))
+            UiHelpers.debug(@ui, "  ip line: #{m[1]} #{m[2]} (owner=#{owner})")
+            yield m[1], m[2], owner
           end
         end
-
-        UiHelpers.debug(@ui, "list_pairs found #{out.length} pair(s)")
-        out
       end
 
-      def entries_in_blocks(scope = :current)
-        content = read
-        return {} if content.to_s.empty?
-
-        start_prefix = "# >>> vagrant-docker-hosts-manager "
-        stop_prefix  = "# <<< vagrant-docker-hosts-manager "
-
-        in_block = false
-        owner    = nil
-        out      = {}
-
-        content.each_line do |raw|
-          line = raw.sub(/\r?\n\z/, "")
-          lstr = line.lstrip
-
-          if lstr.start_with?(start_prefix)
-            in_block = true
-            tail  = lstr[start_prefix.length..-1].to_s
-            owner = tail.split(" (managed)").first.to_s.strip
-            next
-          end
-
-          if lstr.start_with?(stop_prefix)
-            in_block = false
-            owner    = nil
-            next
-          end
-
-          next unless in_block
-          next unless scope == :all || owner == @owner_id
-
-          if lstr =~ /\A\s*(\d{1,3}(?:\.\d{1,3}){3})\s+([^\s#]+)/
-            ip, fqdn = $1, $2
-            if out.key?(fqdn)
-              arr = out[fqdn].is_a?(Array) ? out[fqdn] : [out[fqdn]]
-              arr << ip unless arr.include?(ip)
-              out[fqdn] = arr
-            else
-              out[fqdn] = [ip]
-            end
-          end
-        end
-
-        out
+      def list_pairs(scope = :all)
+        pairs = []
+        each_managed_entry(scope) { |ip, fqdn, owner| pairs << [ip, fqdn, owner] }
+        UiHelpers.debug(@ui, "list_pairs found #{pairs.length} pair(s)")
+        pairs
       end
 
-      def managed_blocks_dump(scope = :all)
-        content = read
-        return "" if content.to_s.empty?
-
-        start_re = /^\s*#\s*>>>\s*vagrant-docker-hosts-manager\s+(.+?)\s*\(managed\)\s*>>>\s*$/i
-        stop_re  = /^\s*#\s*<<<\s*vagrant-docker-hosts-manager\s+(.+?)\s*\(managed\)\s*<<<\s*$/i
-
-        buff     = []
-        cur      = []
-        in_block = false
-        owner    = nil
-
-        content.each_line do |raw|
-          line = raw.delete_suffix("\n").delete_suffix("\r")
-
-          if (m = line.match(start_re))
-            in_block = true
-            owner    = m[1].to_s.strip
-            cur = [line]
-            next
-          end
-
-          if in_block
-            cur << line
-            if line.match?(stop_re)
-              if scope == :all || owner == @owner_id
-                buff << cur.join("\n")
-              end
-              in_block = false
-              owner    = nil
-              cur      = []
-            end
-          end
+      def entries_in_blocks(scope = :current)
+        each_managed_entry(scope).with_object({}) do |(ip, fqdn, _owner), out|
+          arr = (out[fqdn] ||= [])
+          arr << ip unless arr.include?(ip)
         end
-
-        buff.join("\n\n\n")
-      end
-
-      def current_entries
-        entries_in_blocks(:current)
       end
 
       def remove_block_from(content)
@@ -429,6 +412,7 @@ module VagrantDockerHostsManager
               [Security.Principal.WindowsIdentity]::GetCurrent()
             )).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
           }.strip
+          Verbose.log("powershell -Command (check administrator role)")
           out, _err, st = Open3.capture3("powershell", "-NoProfile", "-NonInteractive", "-Command", cmd)
           st.success? && out.to_s.strip.downcase == "true"
         else
@@ -451,6 +435,7 @@ module VagrantDockerHostsManager
         begin
           tf.binmode
           tf.write(content); tf.flush
+          Verbose.log("sudo", "cp", tf.path, real_path)
           system("sudo", "cp", tf.path, real_path) || raise("sudo copy failed")
         ensure
           tf.close!
@@ -458,6 +443,8 @@ module VagrantDockerHostsManager
       end
 
       def write_windows(content)
+        # Try a direct write first; fall back to UAC only when the hosts file
+        # rejects it. Base64/UTF-16LE keeps PowerShell quoting predictable.
         b64  = Base64.strict_encode64(
           content.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
         )
@@ -465,16 +452,31 @@ module VagrantDockerHostsManager
 
         ps = <<~POW
           $ErrorActionPreference = "Stop"
-          $bytes = [System.Convert]::FromBase64String('#{b64}')
-          [System.IO.File]::WriteAllBytes('#{dest}', $bytes)
+          try {
+            $bytes = [System.Convert]::FromBase64String('#{b64}')
+            [System.IO.File]::WriteAllBytes('#{dest}', $bytes)
+            exit 0
+          } catch {
+            exit 1
+          }
         POW
         encoded = Base64.strict_encode64(ps.encode("UTF-16LE"))
+
+        Verbose.log("powershell -EncodedCommand (write hosts file: #{real_path})")
         _out, _err, st = Open3.capture3("powershell", "-NoProfile", "-NonInteractive", "-EncodedCommand", encoded)
         return if st.success?
 
-        elev_ps      = "Start-Process PowerShell -Verb RunAs -Wait " \
-                       "-ArgumentList '-NonInteractive', '-NoProfile', '-EncodedCommand', '#{encoded}'"
+        elev_ps = <<~POW
+          $ErrorActionPreference = 'Stop'
+          try {
+            $p = Start-Process PowerShell -Verb RunAs -Wait -PassThru -ArgumentList '-NonInteractive','-NoProfile','-EncodedCommand','#{encoded}'
+            exit $p.ExitCode
+          } catch {
+            exit 1
+          }
+        POW
         elev_encoded = Base64.strict_encode64(elev_ps.encode("UTF-16LE"))
+        Verbose.log("powershell -EncodedCommand (elevated write hosts file via RunAs: #{real_path})")
         system("powershell", "-NoProfile", "-NonInteractive", "-EncodedCommand", elev_encoded) ||
           raise("elevated write failed")
       end

data/lib/vagrant-docker-hosts-manager/util/i18n.rb

@@ -33,7 +33,7 @@ module VagrantDockerHostsManager
         begin
           if env[:ui] && env[:machine]&.config&.docker_hosts&.respond_to?(:verbose) &&
              env[:machine].config.docker_hosts.verbose
-            env[:ui].info(::I18n.t("messages.lang_set", lang: ::I18n.locale))
+            env[:ui].info(::I18n.t("vdhm.messages.lang_set", lang: ::I18n.locale))
           end
         rescue StandardError
           nil

data/lib/vagrant-docker-hosts-manager/util/verbose.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module VagrantDockerHostsManager
+  module Util
+    module Verbose
+      module_function
+
+      def enabled?
+        ENV["VDHM_VERBOSE"].to_s == "1"
+      end
+
+      def log(*args)
+        return unless enabled?
+
+        line = args.length == 1 && args.first.is_a?(String) ? args.first : args.map(&:to_s).shelljoin
+        warn("[VDHM] #{line}")
+      end
+    end
+  end
+end