dash 3.2.0 → 4.0.0

data/lib/{kamal → dash}/cli/base.rb

@@ -1,7 +1,7 @@
 require "thor"
-require "kamal/sshkit_with_ext"
+require "dash/sshkit_with_ext"
 
-module Kamal::Cli
+module Dash::Cli
   class Base < Thor
     include SSHKit::DSL
 
@@ -16,7 +16,13 @@ module Kamal::Cli
     HOOK_MUTEX = Mutex.new
 
     def self.exit_on_failure?() true end
-    def self.dynamic_command_class() Kamal::Cli::Alias::Command end
+    def self.dynamic_command_class() Dash::Cli::Alias::Command end
+
+    # One legacy-project-directory deprecation notice per process. Tests reset it
+    # in CliTestCase, the same way they reset the DASH singleton.
+    class << self
+      attr_accessor :legacy_project_directory_warned
+    end
 
     class_option :verbose, type: :boolean, aliases: "-v", desc: "Detailed logging"
     class_option :quiet, type: :boolean, aliases: "-q", desc: "Minimal logging"
@@ -37,7 +43,7 @@ module Kamal::Cli
     class_option :lock_wait_interval, type: :numeric, default: 15, desc: "Seconds between deploy lock polls when --lock-wait is set"
 
     def initialize(args = [], local_options = {}, config = {})
-      if config[:current_command].is_a?(Kamal::Cli::Alias::Command)
+      if config[:current_command].is_a?(Dash::Cli::Alias::Command)
         # When Thor generates a dynamic command, it doesn't attempt to parse the arguments.
         # For our purposes, it means the arguments are passed in args rather than local_options.
         super([], args, config)
@@ -45,36 +51,39 @@ module Kamal::Cli
         super
       end
 
-      initialize_commander unless KAMAL.configured?
+      unless DASH.configured?
+        initialize_commander
+        warn_on_legacy_project_directory(config[:current_command]&.name)
+      end
     end
 
-    # Public so collaborators like Kamal::Cli::App::Boot can fire hooks, but not a Thor command.
+    # Public so collaborators like Dash::Cli::App::Boot can fire hooks, but not a Thor command.
     no_commands do
       def run_hook(hook, **extra_details)
-        if !options[:skip_hooks] && KAMAL.hook.hook_exists?(hook)
+        if !options[:skip_hooks] && DASH.hook.hook_exists?(hook)
           details = {
-            hosts: KAMAL.hosts.join(","),
-            roles: KAMAL.specific_roles&.join(","),
-            lock: KAMAL.holding_lock?.to_s,
+            hosts: DASH.hosts.join(","),
+            roles: DASH.specific_roles&.join(","),
+            lock: DASH.holding_lock?.to_s,
             command: command,
             subcommand: subcommand
           }.compact
 
-          hooks_output = KAMAL.config.hooks_output_for(hook)
+          hooks_output = DASH.config.hooks_output_for(hook)
 
           # CLI flags override config: -q hides all, -v shows all
           # Config setting :verbose forces output, :quiet forces silence
-          hook_verbosity = if KAMAL.verbosity == :info && hooks_output
+          hook_verbosity = if DASH.verbosity == :info && hooks_output
             VERBOSITY.fetch(hooks_output)
           else
-            KAMAL.verbosity
+            DASH.verbosity
           end
 
           HOOK_MUTEX.synchronize do
-            with_env KAMAL.hook.env(**details, **extra_details) do
-              KAMAL.with_verbosity(hook_verbosity) do
+            with_env DASH.hook.env(**details, **extra_details) do
+              DASH.with_verbosity(hook_verbosity) do
                 run_locally do
-                  execute *KAMAL.hook.run(hook)
+                  execute *DASH.hook.run(hook)
                 end
               end
             rescue SSHKit::Command::Failed => e
@@ -90,8 +99,23 @@ module Kamal::Cli
         options.merge(@_initializer.last[:class_options] || {})
       end
 
+      # Process-scoped rather than commander-scoped: Dash::Cli::Alias::Command
+      # resets DASH and re-enters Dash::Cli::Main.start, so an aliased command
+      # builds a second commander and would otherwise warn twice. `dash migrate`
+      # is exempt - telling an operator to run the command they are running is noise.
+      def warn_on_legacy_project_directory(command_name)
+        return if command_name == "migrate"
+        return if Dash::Cli::Base.legacy_project_directory_warned
+        return unless Dash::ProjectDirectory.legacy?
+
+        Dash::Cli::Base.legacy_project_directory_warned = true
+
+        say "Using the legacy #{Dash::ProjectDirectory::LEGACY}/ project directory. Run `dash migrate` to move it to " \
+            "#{Dash::ProjectDirectory::CURRENT}/ (#{Dash::ProjectDirectory::LEGACY}/ support is removed in dash 5.0).", :yellow
+      end
+
       def initialize_commander
-        KAMAL.tap do |commander|
+        DASH.tap do |commander|
           if options[:verbose]
             ENV["VERBOSE"] = "1" # For backtraces via cli/start
             commander.verbosity = VERBOSITY[:verbose]
@@ -128,7 +152,7 @@ module Kamal::Cli
       # Deploy lock outside, server lock inside. Every caller acquires in that
       # order, and deploy locks are unique per destination, so no cycle forms.
       def modify(lock: false, server_lock: false)
-        KAMAL.modify(command: command, subcommand: subcommand) do
+        DASH.modify(command: command, subcommand: subcommand) do
           guarded = -> { server_lock ? with_server_lock { yield } : yield }
 
           lock ? with_lock(&guarded) : guarded.call
@@ -137,21 +161,21 @@ module Kamal::Cli
 
       def say(message = "", *)
         super unless options[:raw]
-        KAMAL.log(message.to_s)
+        DASH.log(message.to_s)
       end
 
       # Raw output is written straight to stdout for piping, so silence SSHKit's
       # command echoing that would otherwise corrupt the byte stream.
       def with_raw_output(raw, &block)
-        raw ? KAMAL.with_verbosity(:error, &block) : block.call
+        raw ? DASH.with_verbosity(:error, &block) : block.call
       end
 
-      # kamal-proxy is one container per host, shared by every destination
+      # dash-proxy is one container per host, shared by every destination
       # deployed there, but the deploy lock is per-destination — so two
       # destinations deploying at once take different locks and both mutate the
       # same proxy. Anything touching the proxy takes this lock as well.
       def with_server_lock
-        if KAMAL.holding_server_lock?
+        if DASH.holding_server_lock?
           yield
         else
           acquire_server_lock
@@ -173,8 +197,8 @@ module Kamal::Cli
       def acquire_server_lock
         ensure_run_directory
 
-        timeout = KAMAL.lock_wait_timeout
-        interval = KAMAL.lock_wait_interval
+        timeout = DASH.lock_wait_timeout
+        interval = DASH.lock_wait_interval
         deadline = Time.now + timeout
         details_shown = false
 
@@ -187,7 +211,7 @@ module Kamal::Cli
 
           begin
             server_lock_hosts.each do |host|
-              execute_lock_acquire(AUTOMATIC_DEPLOY_LOCK_MESSAGE, lock: KAMAL.server_lock, hosts: host)
+              execute_lock_acquire(AUTOMATIC_DEPLOY_LOCK_MESSAGE, lock: DASH.server_lock, hosts: host)
               held << host
             end
 
@@ -200,7 +224,7 @@ module Kamal::Cli
               # That means the lock is free, not that anything went wrong, so
               # it must never escape as LockMissingError and fail the deploy.
               status = begin
-                capture_lock_status(lock: KAMAL.server_lock, hosts: server_lock_hosts.first)
+                capture_lock_status(lock: DASH.server_lock, hosts: server_lock_hosts.first)
               rescue LockMissingError
                 nil
               end
@@ -227,14 +251,14 @@ module Kamal::Cli
           end
         end
 
-        KAMAL.holding_server_lock = true
+        DASH.holding_server_lock = true
       end
 
       def release_server_lock
         say "Releasing the server lock...", :magenta
         release_server_lock_on(server_lock_hosts)
 
-        KAMAL.holding_server_lock = false
+        DASH.holding_server_lock = false
       end
 
       # Only ever called with hosts this process actually locked, so a missing
@@ -242,18 +266,18 @@ module Kamal::Cli
       # another deploy's lock.
       def release_server_lock_on(hosts)
         Array(hosts).each do |host|
-          execute_lock_release(lock: KAMAL.server_lock, hosts: host)
+          execute_lock_release(lock: DASH.server_lock, hosts: host)
         rescue LockMissingError
           nil
         end
       end
 
       def server_lock_hosts
-        KAMAL.proxy_hosts.presence || KAMAL.hosts
+        DASH.proxy_hosts.presence || DASH.hosts
       end
 
       def with_lock
-        if KAMAL.holding_lock?
+        if DASH.holding_lock?
           yield
         else
           acquire_lock
@@ -286,7 +310,7 @@ module Kamal::Cli
       def acquire_lock
         ensure_run_directory
 
-        if KAMAL.lock_wait
+        if DASH.lock_wait
           acquire_lock_with_wait
         else
           raise_if_locked do
@@ -295,12 +319,12 @@ module Kamal::Cli
           end
         end
 
-        KAMAL.holding_lock = true
+        DASH.holding_lock = true
       end
 
       def acquire_lock_with_wait
-        timeout = KAMAL.lock_wait_timeout
-        interval = KAMAL.lock_wait_interval
+        timeout = DASH.lock_wait_timeout
+        interval = DASH.lock_wait_interval
         deadline = Time.now + timeout
         details_shown = false
 
@@ -338,7 +362,7 @@ module Kamal::Cli
         say "Releasing the deploy lock...", :magenta
         execute_lock_release
 
-        KAMAL.holding_lock = false
+        DASH.holding_lock = false
       end
 
       def raise_if_locked
@@ -349,21 +373,21 @@ module Kamal::Cli
         raise LockError, "Deploy lock found. Run 'dash lock help' for more information"
       end
 
-      def execute_lock_acquire(message, lock: KAMAL.lock, hosts: KAMAL.primary_host)
-        on(hosts) { execute *lock.acquire(message, KAMAL.config.version), verbosity: :debug }
+      def execute_lock_acquire(message, lock: DASH.lock, hosts: DASH.primary_host)
+        on(hosts) { execute *lock.acquire(message, DASH.config.version), verbosity: :debug }
       rescue SSHKit::Runner::ExecuteError => e
         raise LockHeldError if e.message =~ /cannot create directory/
         raise
       end
 
-      def execute_lock_release(lock: KAMAL.lock, hosts: KAMAL.primary_host)
+      def execute_lock_release(lock: DASH.lock, hosts: DASH.primary_host)
         on(hosts) { execute *lock.release, verbosity: :debug }
       rescue SSHKit::Runner::ExecuteError => e
         raise LockMissingError if e.message =~ /No such file or directory/
         raise
       end
 
-      def capture_lock_status(lock: KAMAL.lock, hosts: KAMAL.primary_host)
+      def capture_lock_status(lock: DASH.lock, hosts: DASH.primary_host)
         status = nil
         on(hosts) { status = capture_with_debug(*lock.status) }
         status
@@ -379,19 +403,19 @@ module Kamal::Cli
       end
 
       def pre_connect_if_required
-        if !KAMAL.connected?
+        if !DASH.connected?
           run_hook "pre-connect", secrets: true unless options[:skip_hooks]
-          KAMAL.connected = true
+          DASH.connected = true
         end
       end
 
       def command
         @kamal_command ||= begin
           invocation_class, invocation_commands = *first_invocation
-          if invocation_class == Kamal::Cli::Main
+          if invocation_class == Dash::Cli::Main
             invocation_commands[0]
           else
-            Kamal::Cli::Main.subcommand_classes.find { |command, clazz| clazz == invocation_class }[0]
+            Dash::Cli::Main.subcommand_classes.find { |command, clazz| clazz == invocation_class }[0]
           end
         end
       end
@@ -399,7 +423,7 @@ module Kamal::Cli
       def subcommand
         @kamal_subcommand ||= begin
           invocation_class, invocation_commands = *first_invocation
-          invocation_commands[0] if invocation_class != Kamal::Cli::Main
+          invocation_commands[0] if invocation_class != Dash::Cli::Main
         end
       end
 
@@ -412,8 +436,8 @@ module Kamal::Cli
       end
 
       def ensure_run_directory
-        on(KAMAL.hosts) do
-          execute(*KAMAL.server.ensure_run_directory)
+        on(DASH.hosts) do
+          execute(*DASH.server.ensure_run_directory)
         end
       end
 
@@ -429,7 +453,7 @@ module Kamal::Cli
       def ensure_docker_installed
         run_locally do
           begin
-            execute *KAMAL.builder.ensure_docker_installed
+            execute *DASH.builder.ensure_docker_installed
           rescue SSHKit::Command::Failed => e
             error = e.message =~ /command not found/ ?
               "Docker is not installed locally" :

data/lib/dash/cli/build/clone.rb

@@ -0,0 +1,59 @@
+class Dash::Cli::Build::Clone
+  attr_reader :sshkit
+  delegate :info, :error, :execute, :capture_with_info, to: :sshkit
+
+  def initialize(sshkit)
+    @sshkit = sshkit
+  end
+
+  def prepare
+    begin
+      clone_repo
+    rescue SSHKit::Command::Failed => e
+      if e.message =~ /already exists and is not an empty directory/
+        reset
+      else
+        raise Dash::Cli::Build::BuildError, "Failed to clone repo: #{e.message}"
+      end
+    end
+
+    validate!
+  rescue Dash::Cli::Build::BuildError => e
+    error "Error preparing clone: #{e.message}, deleting and retrying..."
+
+    FileUtils.rm_rf DASH.config.builder.clone_directory
+    clone_repo
+    validate!
+  end
+
+  private
+    def clone_repo
+      info "Cloning repo into build directory `#{DASH.config.builder.build_directory}`..."
+
+      FileUtils.mkdir_p DASH.config.builder.clone_directory
+      execute *DASH.builder.clone
+    end
+
+    def reset
+      info "Resetting local clone as `#{DASH.config.builder.build_directory}` already exists..."
+
+      DASH.builder.clone_reset_steps.each { |step| execute *step }
+    rescue SSHKit::Command::Failed => e
+      raise Dash::Cli::Build::BuildError, "Failed to clone repo: #{e.message}"
+    end
+
+    def validate!
+      status = capture_with_info(*DASH.builder.clone_status).strip
+
+      unless status.empty?
+        raise Dash::Cli::Build::BuildError, "Clone in #{DASH.config.builder.build_directory} is dirty, #{status}"
+      end
+
+      revision = capture_with_info(*DASH.builder.clone_revision).strip
+      if revision != Dash::Git.revision
+        raise Dash::Cli::Build::BuildError, "Clone in #{DASH.config.builder.build_directory} is not on the correct revision, expected `#{Dash::Git.revision}` but got `#{revision}`"
+      end
+    rescue SSHKit::Command::Failed => e
+      raise Dash::Cli::Build::BuildError, "Failed to validate clone: #{e.message}"
+    end
+end

data/lib/{kamal → dash}/cli/build/port_forwarding.rb

@@ -1,6 +1,6 @@
 require "concurrent/atomic/count_down_latch"
 
-class Kamal::Cli::Build::PortForwarding
+class Dash::Cli::Build::PortForwarding
   attr_reader :hosts, :port, :ssh_options
 
   def initialize(hosts, port, **ssh_options)

data/lib/{kamal → dash}/cli/build.rb

@@ -1,4 +1,4 @@
-class Kamal::Cli::Build < Kamal::Cli::Base
+class Dash::Cli::Build < Dash::Cli::Base
   class BuildError < StandardError; end
 
   desc "deliver", "Build app and push app image to registry then pull image on servers"
@@ -18,14 +18,14 @@ class Kamal::Cli::Build < Kamal::Cli::Base
     pre_connect_if_required
 
     ensure_docker_installed
-    setup_local_registry      if KAMAL.registry.local?
-    login_to_registry_locally unless KAMAL.registry.local?
+    setup_local_registry      if DASH.registry.local?
+    login_to_registry_locally unless DASH.registry.local?
 
     run_hook "pre-build"
 
-    uncommitted_changes = Kamal::Git.uncommitted_changes
+    uncommitted_changes = Dash::Git.uncommitted_changes
 
-    if KAMAL.config.builder.git_clone?
+    if DASH.config.builder.git_clone?
       if uncommitted_changes.present?
         say "Building from a local git clone, so ignoring these uncommitted changes:\n #{uncommitted_changes}", :yellow
       end
@@ -38,10 +38,10 @@ class Kamal::Cli::Build < Kamal::Cli::Base
     end
 
     forward_local_registry_port_for_remote_builder do
-      with_env(KAMAL.config.builder.secrets) do
+      with_env(DASH.config.builder.secrets) do
         run_locally do
           begin
-            execute *KAMAL.builder.inspect_builder
+            execute *DASH.builder.inspect_builder
           rescue SSHKit::Command::Failed => e
             if e.message =~ /(context not found|no builder|no compatible builder|does not exist)/
               warn "Missing compatible builder, so creating a new one first"
@@ -57,10 +57,10 @@ class Kamal::Cli::Build < Kamal::Cli::Base
           end
 
           # Get the command here to ensure the Dir.chdir doesn't interfere with it
-          push = KAMAL.builder.push(cli.options[:output], no_cache: cli.options[:no_cache])
+          push = DASH.builder.push(cli.options[:output], no_cache: cli.options[:no_cache])
 
-          KAMAL.with_verbosity(:debug) do
-            Dir.chdir(KAMAL.config.builder.build_directory) { execute *push, env: KAMAL.builder.push_env }
+          DASH.with_verbosity(:debug) do
+            Dir.chdir(DASH.config.builder.build_directory) { execute *push, env: DASH.builder.push_env }
           end
         end
       end
@@ -69,31 +69,31 @@ class Kamal::Cli::Build < Kamal::Cli::Base
 
   desc "pull", "Pull app image from registry onto servers"
   def pull
-    login_to_registry_remotely unless KAMAL.registry.local?
+    login_to_registry_remotely unless DASH.registry.local?
 
-    forward_local_registry_port(KAMAL.hosts, **KAMAL.config.ssh.options) do
+    forward_local_registry_port(DASH.hosts, **DASH.config.ssh.options) do
       if (first_hosts = mirror_hosts).any?
         #  Pull on a single host per mirror first to seed them
         say "Pulling image on #{first_hosts.join(", ")} to seed the #{"mirror".pluralize(first_hosts.count)}...", :magenta
         pull_on_hosts(first_hosts)
         say "Pulling image on remaining hosts...", :magenta
-        pull_on_hosts(KAMAL.app_hosts - first_hosts)
+        pull_on_hosts(DASH.app_hosts - first_hosts)
       else
-        pull_on_hosts(KAMAL.app_hosts)
+        pull_on_hosts(DASH.app_hosts)
       end
     end
   end
 
   desc "create", "Create a build setup"
   def create
-    if (remote_host = KAMAL.config.builder.remote)
+    if (remote_host = DASH.config.builder.remote)
       connect_to_remote_host(remote_host)
     end
 
     run_locally do
       begin
-        debug "Using builder: #{KAMAL.builder.name}"
-        execute *KAMAL.builder.create
+        debug "Using builder: #{DASH.builder.name}"
+        execute *DASH.builder.create
       rescue SSHKit::Command::Failed => e
         if e.message =~ /stderr=(.*)/
           error "Couldn't create remote builder: #{$1}"
@@ -108,16 +108,16 @@ class Kamal::Cli::Build < Kamal::Cli::Base
   desc "remove", "Remove build setup"
   def remove
     run_locally do
-      debug "Using builder: #{KAMAL.builder.name}"
-      execute *KAMAL.builder.remove
+      debug "Using builder: #{DASH.builder.name}"
+      execute *DASH.builder.remove
     end
   end
 
   desc "details", "Show build setup"
   def details
     run_locally do
-      puts "Builder: #{KAMAL.builder.name}"
-      puts capture(*KAMAL.builder.info)
+      puts "Builder: #{DASH.builder.name}"
+      puts capture(*DASH.builder.info)
     end
   end
 
@@ -129,9 +129,9 @@ class Kamal::Cli::Build < Kamal::Cli::Base
 
     ensure_docker_installed
 
-    docker_included_files = Set.new(Kamal::Docker.included_files)
-    git_uncommitted_files = Set.new(Kamal::Git.uncommitted_files)
-    git_untracked_files = Set.new(Kamal::Git.untracked_files)
+    docker_included_files = Set.new(Dash::Docker.included_files)
+    git_uncommitted_files = Set.new(Dash::Git.uncommitted_files)
+    git_untracked_files = Set.new(Dash::Git.untracked_files)
 
     docker_uncommitted_files = docker_included_files & git_uncommitted_files
     if docker_uncommitted_files.any?
@@ -147,10 +147,10 @@ class Kamal::Cli::Build < Kamal::Cli::Base
       say
     end
 
-    with_env(KAMAL.config.builder.secrets) do
+    with_env(DASH.config.builder.secrets) do
       run_locally do
-        build = KAMAL.builder.push(cli.options[:output], tag_as_dirty: true, no_cache: cli.options[:no_cache])
-        KAMAL.with_verbosity(:debug) do
+        build = DASH.builder.push(cli.options[:output], tag_as_dirty: true, no_cache: cli.options[:no_cache])
+        DASH.with_verbosity(:debug) do
           execute(*build)
         end
       end
@@ -172,10 +172,10 @@ class Kamal::Cli::Build < Kamal::Cli::Base
     end
 
     def mirror_hosts
-      if KAMAL.app_hosts.many?
+      if DASH.app_hosts.many?
         mirror_hosts = Concurrent::Hash.new
-        on(KAMAL.app_hosts) do |host|
-          first_mirror = capture_with_info(*KAMAL.builder.first_mirror).strip.presence
+        on(DASH.app_hosts) do |host|
+          first_mirror = capture_with_info(*DASH.builder.first_mirror).strip.presence
           mirror_hosts[first_mirror] ||= host.to_s if first_mirror
         rescue SSHKit::Command::Failed => e
           raise unless e.message =~ /error calling index: reflect: slice index out of range/
@@ -188,34 +188,34 @@ class Kamal::Cli::Build < Kamal::Cli::Base
 
     def pull_on_hosts(hosts)
       on(hosts) do
-        execute *KAMAL.auditor.record("Pulled image with version #{KAMAL.config.version}"), verbosity: :debug
-        execute *KAMAL.builder.clean, raise_on_non_zero_exit: false
-        execute *KAMAL.builder.pull
-        execute *KAMAL.builder.validate_image
+        execute *DASH.auditor.record("Pulled image with version #{DASH.config.version}"), verbosity: :debug
+        execute *DASH.builder.clean, raise_on_non_zero_exit: false
+        execute *DASH.builder.pull
+        execute *DASH.builder.validate_image
       end
     end
 
     def setup_local_registry
       run_locally do
-        execute *KAMAL.registry.setup
+        execute *DASH.registry.setup
       end
     end
 
     def login_to_registry_locally
       run_locally do
-        execute *KAMAL.registry.login
+        execute *DASH.registry.login
       end
     end
 
     def login_to_registry_remotely
-      on(KAMAL.app_hosts) do
-        execute *KAMAL.registry.login
+      on(DASH.app_hosts) do
+        execute *DASH.registry.login
       end
     end
 
     def forward_local_registry_port_for_remote_builder(&block)
-      if KAMAL.builder.remote?
-        remote_uri = URI(KAMAL.config.builder.remote)
+      if DASH.builder.remote?
+        remote_uri = URI(DASH.config.builder.remote)
         forward_local_registry_port([ remote_uri.host ], **remote_builder_ssh_options(remote_uri), &block)
       else
         yield
@@ -223,9 +223,9 @@ class Kamal::Cli::Build < Kamal::Cli::Base
     end
 
     def forward_local_registry_port(hosts, **ssh_options, &block)
-      if KAMAL.config.registry.local?
+      if DASH.config.registry.local?
         say "Setting up local registry port forwarding to #{hosts.join(', ')}..."
-        PortForwarding.new(hosts, KAMAL.config.registry.local_port, **ssh_options).forward(&block)
+        PortForwarding.new(hosts, DASH.config.registry.local_port, **ssh_options).forward(&block)
       else
         yield
       end
@@ -234,9 +234,9 @@ class Kamal::Cli::Build < Kamal::Cli::Base
     def remote_builder_ssh_options(remote_uri)
       { user: remote_uri.user,
         port: remote_uri.port,
-        keepalive: KAMAL.config.ssh.options[:keepalive],
-        keepalive_interval: KAMAL.config.ssh.options[:keepalive_interval],
-        logger: KAMAL.config.ssh.options[:logger]
+        keepalive: DASH.config.ssh.options[:keepalive],
+        keepalive_interval: DASH.config.ssh.options[:keepalive_interval],
+        logger: DASH.config.ssh.options[:logger]
       }.compact
     end
 end

data/lib/{kamal → dash}/cli/doctor/config_checks.rb

@@ -1,17 +1,17 @@
 # Checks that only read the configuration — no SSH, no network. They report problems
 # that are visible in deploy.yml alone, so they still run when every host is unreachable.
-class Kamal::Cli::Doctor::ConfigChecks
+class Dash::Cli::Doctor::ConfigChecks
   def run
     readiness_results
   end
 
   private
     def result(check, target, status, detail)
-      Kamal::Cli::Doctor::Result.new(check, target, status, detail)
+      Dash::Cli::Doctor::Result.new(check, target, status, detail)
     end
 
     def readiness_results
-      KAMAL.roles.map { |role| readiness_check(role) }
+      DASH.roles.map { |role| readiness_check(role) }
     end
 
     def readiness_check(role)