dash 2.12.0

data/lib/kamal/cli/app.rb

@@ -0,0 +1,368 @@
+class Kamal::Cli::App < Kamal::Cli::Base
+  desc "boot", "Boot app on servers (or reboot app if already running)"
+  def boot
+    modify(lock: true) do
+      say "Get most recent version available as an image...", :magenta unless options[:version]
+      using_version(version_or_latest) do |version|
+        say "Start container with version #{version} (or reboot if already running)...", :magenta
+
+        # Assets are prepared in a separate step to ensure they are on all hosts before booting
+        on(KAMAL.app_hosts) do
+          Kamal::Cli::App::ErrorPages.new(host, self).run
+
+          KAMAL.roles_on(host).each do |role|
+            Kamal::Cli::App::Assets.new(host, role, self).run
+            Kamal::Cli::App::SslCertificates.new(host, role, self).run
+          end
+        end
+
+        # Primary hosts and roles are returned first, so they can open the barrier
+        barrier = Kamal::Cli::Healthcheck::Barrier.new
+
+        host_boot_groups.each do |hosts|
+          host_list = Array(hosts).join(",")
+          run_hook "pre-app-boot", hosts: host_list
+
+          on_roles(KAMAL.roles, hosts: hosts, parallel: KAMAL.config.boot.parallel_roles) do |host, role|
+            Kamal::Cli::App::Boot.new(host, role, self, version, barrier).run
+          end
+
+          run_hook "post-app-boot", hosts: host_list
+          sleep KAMAL.config.boot.wait if KAMAL.config.boot.wait
+        end
+
+        # Tag once the app booted on all hosts
+        on(KAMAL.app_hosts) do |host|
+          execute *KAMAL.auditor.record("Tagging #{KAMAL.config.absolute_image} as the latest image"), verbosity: :debug
+          execute *KAMAL.app.tag_latest_image
+        end
+      end
+    end
+  end
+
+  desc "start", "Start existing app container on servers"
+  def start
+    modify(lock: true) do
+      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts, parallel: KAMAL.config.boot.parallel_roles) do |host, role|
+        app = KAMAL.app(role: role, host: host)
+        execute *KAMAL.auditor.record("Started app version #{KAMAL.config.version}"), verbosity: :debug
+        execute *app.start, raise_on_non_zero_exit: false
+
+        if role.running_proxy?
+          version = capture_with_info(*app.current_running_version, raise_on_non_zero_exit: false).strip
+          endpoint = capture_with_info(*app.container_id_for_version(version)).strip
+          raise Kamal::Cli::BootError, "Failed to get endpoint for #{role} on #{host}, did the container boot?" if endpoint.empty?
+
+          execute *app.deploy(target: endpoint)
+        end
+      end
+    end
+  end
+
+  desc "stop", "Stop app container on servers"
+  def stop
+    modify(lock: true) do
+      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts, parallel: KAMAL.config.boot.parallel_roles) do |host, role|
+        app = KAMAL.app(role: role, host: host)
+        execute *KAMAL.auditor.record("Stopped app", role: role), verbosity: :debug
+
+        if role.running_proxy?
+          version = capture_with_info(*app.current_running_version, raise_on_non_zero_exit: false).strip
+          endpoint = capture_with_info(*app.container_id_for_version(version)).strip
+          if endpoint.present?
+            execute *app.remove, raise_on_non_zero_exit: false
+          end
+        end
+
+        execute *app.stop, raise_on_non_zero_exit: false
+      end
+    end
+  end
+
+  # FIXME: Drop in favor of just containers?
+  desc "details", "Show details about app containers"
+  def details
+    quiet = options[:quiet]
+    on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
+      puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).info), quiet: quiet
+    end
+  end
+
+  desc "exec [CMD...]", "Execute a custom command on servers within the app container (use --help to show options)"
+  option :interactive, aliases: "-i", type: :boolean, default: false, desc: "Execute command over ssh for an interactive shell (use for console/bash)"
+  option :reuse, type: :boolean, default: false, desc: "Reuse currently running container instead of starting a new one"
+  option :env, aliases: "-e", type: :hash, desc: "Set environment variables for the command"
+  option :detach, type: :boolean, default: false, desc: "Execute command in a detached container"
+  option :raw, type: :boolean, default: false, desc: "Output raw, unmodified stdout"
+  def exec(*cmd)
+    raw = options[:raw]
+
+    if (incompatible_options = [ :interactive, :reuse ].select { |key| options[:detach] && options[key] }.presence)
+      raise ArgumentError, "Detach is not compatible with #{incompatible_options.join(" or ")}"
+    end
+
+    if raw && (incompatible_options = [ :interactive, :detach ].select { |key| options[key] }.presence)
+      raise ArgumentError, "Raw is not compatible with #{incompatible_options.join(" or ")}"
+    end
+
+    if cmd.empty?
+      raise ArgumentError, "No command provided. You must specify a command to execute."
+    end
+
+    with_raw_output(raw) do
+      pre_connect_if_required
+
+      cmd = Kamal::Utils.join_commands(cmd)
+      env = options[:env]
+      detach = options[:detach]
+      quiet = options[:quiet]
+      case
+      when options[:interactive] && options[:reuse]
+        say "Get current version of running container...", :magenta unless options[:version]
+        using_version(options[:version] || current_running_version) do |version|
+          say "Launching interactive command with version #{version} via SSH from existing container on #{KAMAL.primary_host}...", :magenta
+          run_locally { exec KAMAL.app(role: KAMAL.primary_role, host: KAMAL.primary_host).execute_in_existing_container_over_ssh(cmd, env: env) }
+        end
+
+      when options[:interactive]
+        say "Get most recent version available as an image...", :magenta unless options[:version]
+        using_version(version_or_latest) do |version|
+          say "Launching interactive command with version #{version} via SSH from new container on #{KAMAL.primary_host}...", :magenta
+          on(KAMAL.primary_host) { execute *KAMAL.registry.login }
+          run_locally do
+            exec KAMAL.app(role: KAMAL.primary_role, host: KAMAL.primary_host).execute_in_new_container_over_ssh(cmd, env: env)
+          end
+        end
+
+      when options[:reuse]
+        say "Get current version of running container...", :magenta unless options[:version]
+        using_version(options[:version] || current_running_version) do |version|
+          say "Launching command with version #{version} from existing container...", :magenta
+
+          on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
+            execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on app version #{version}", role: role), verbosity: :debug
+            puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).execute_in_existing_container(cmd, env: env), strip: !raw), quiet: quiet, raw: raw
+          end
+        end
+
+      else
+        say "Get most recent version available as an image...", :magenta unless options[:version]
+        using_version(version_or_latest) do |version|
+          say "Launching command with version #{version} from new container...", :magenta
+          on(KAMAL.app_hosts) { execute *KAMAL.registry.login }
+
+          on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
+            execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on app version #{version}"), verbosity: :debug
+            puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).execute_in_new_container(cmd, env: env, detach: detach), strip: !raw), quiet: quiet, raw: raw
+          end
+        end
+      end
+    end
+  end
+
+  desc "containers", "Show app containers on servers"
+  def containers
+    quiet = options[:quiet]
+    on(KAMAL.app_hosts) { |host| puts_by_host host, capture_with_info(*KAMAL.app.list_containers), quiet: quiet }
+  end
+
+  desc "stale_containers", "Detect app stale containers"
+  option :stop, aliases: "-s", type: :boolean, default: false, desc: "Stop the stale containers found"
+  def stale_containers
+    quiet = options[:quiet]
+    stop = options[:stop]
+
+    with_lock_if_stopping do
+      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
+        app = KAMAL.app(role: role, host: host)
+        versions = capture_with_info(*app.list_versions, raise_on_non_zero_exit: false).split("\n")
+        versions -= [ capture_with_info(*app.current_running_version, raise_on_non_zero_exit: false).strip ]
+
+        versions.each do |version|
+          if stop
+            puts_by_host host, "Stopping stale container for role #{role} with version #{version}", quiet: quiet
+            execute *app.stop(version: version), raise_on_non_zero_exit: false
+          else
+            puts_by_host host,  "Detected stale container for role #{role} with version #{version} (use `kamal app stale_containers --stop` to stop)", quiet: quiet
+          end
+        end
+      end
+    end
+  end
+
+  desc "images", "Show app images on servers"
+  def images
+    quiet = options[:quiet]
+    on(KAMAL.app_hosts) { |host| puts_by_host host, capture_with_info(*KAMAL.app.list_images), quiet: quiet }
+  end
+
+  desc "logs", "Show log lines from app on servers (use --help to show options)"
+  option :since, aliases: "-s", desc: "Show lines since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)"
+  option :lines, type: :numeric, aliases: "-n", desc: "Number of lines to show from each server"
+  option :grep, aliases: "-g", desc: "Show lines with grep match only (use this to fetch specific requests by id)"
+  option :grep_options, desc: "Additional options supplied to grep"
+  option :follow, aliases: "-f", desc: "Follow log on primary server (or specific host set by --hosts)"
+  option :skip_timestamps, type: :boolean, aliases: "-T", desc: "Skip appending timestamps to logging output"
+  option :container_id, desc: "Docker container ID to fetch logs"
+  def logs
+    # FIXME: Catch when app containers aren't running
+
+    grep = options[:grep]
+    grep_options = options[:grep_options]
+    since = options[:since]
+    container_id = options[:container_id]
+    timestamps = !options[:skip_timestamps]
+    quiet = options[:quiet]
+
+    if options[:follow]
+      lines = options[:lines].presence || ((since || grep) ? nil : 10) # Default to 10 lines if since or grep isn't set
+
+      run_locally do
+        info "Following logs on #{KAMAL.primary_host}..."
+
+        KAMAL.specific_roles ||= [ KAMAL.primary_role.name ]
+        role = KAMAL.roles_on(KAMAL.primary_host).first
+
+        app = KAMAL.app(role: role, host: host)
+        info app.follow_logs(host: KAMAL.primary_host, container_id: container_id, timestamps: timestamps, lines: lines, grep: grep, grep_options: grep_options)
+        exec app.follow_logs(host: KAMAL.primary_host, container_id: container_id, timestamps: timestamps, lines: lines, grep: grep, grep_options: grep_options)
+      end
+    else
+      lines = options[:lines].presence || ((since || grep) ? nil : 100) # Default to 100 lines if since or grep isn't set
+
+      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
+        begin
+          puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).logs(container_id: container_id, timestamps: timestamps, since: since, lines: lines, grep: grep, grep_options: grep_options)), quiet: quiet
+        rescue SSHKit::Command::Failed
+          puts_by_host host, "Nothing found", quiet: quiet
+        end
+      end
+    end
+  end
+
+  desc "remove", "Remove app containers and images from servers"
+  def remove
+    modify(lock: true) do
+      stop
+      remove_containers
+      remove_images
+      remove_app_directories
+    end
+  end
+
+  desc "live", "Set the app to live mode"
+  def live
+    modify(lock: true) do
+      on_roles(KAMAL.roles, hosts: KAMAL.proxy_hosts) do |host, role|
+        execute *KAMAL.app(role: role, host: host).live if role.running_proxy?
+      end
+    end
+  end
+
+  desc "maintenance", "Set the app to maintenance mode"
+  option :drain_timeout, type: :numeric, desc: "How long to allow in-flight requests to complete (defaults to drain_timeout from config)"
+  option :message, type: :string, desc: "Message to display to clients while stopped"
+  def maintenance
+    maintenance_options = { drain_timeout: options[:drain_timeout] || KAMAL.config.drain_timeout, message: options[:message] }
+
+    modify(lock: true) do
+      on_roles(KAMAL.roles, hosts: KAMAL.proxy_hosts) do |host, role|
+        execute *KAMAL.app(role: role, host: host).maintenance(**maintenance_options) if role.running_proxy?
+      end
+    end
+  end
+
+  desc "remove_container [VERSION]", "Remove app container with given version from servers", hide: true
+  def remove_container(version)
+    modify(lock: true) do
+      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
+        execute *KAMAL.auditor.record("Removed app container with version #{version}", role: role), verbosity: :debug
+        execute *KAMAL.app(role: role, host: host).remove_container(version: version)
+      end
+    end
+  end
+
+  desc "remove_containers", "Remove all app containers from servers", hide: true
+  def remove_containers
+    modify(lock: true) do
+      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
+        execute *KAMAL.auditor.record("Removed all app containers", role: role), verbosity: :debug
+        execute *KAMAL.app(role: role, host: host).remove_containers
+      end
+    end
+  end
+
+  desc "remove_images", "Remove all app images from servers", hide: true
+  def remove_images
+    modify(lock: true) do
+      on(hosts_removing_all_roles) do
+        execute *KAMAL.auditor.record("Removed all app images"), verbosity: :debug
+        execute *KAMAL.app.remove_images
+      end
+    end
+  end
+
+  desc "remove_app_directories", "Remove the app directories from servers", hide: true
+  def remove_app_directories
+    modify(lock: true) do
+      on(hosts_removing_all_roles) do |host|
+        execute *KAMAL.server.remove_app_directory, raise_on_non_zero_exit: false
+        execute *KAMAL.auditor.record("Removed #{KAMAL.config.app_directory}"), verbosity: :debug
+        execute *KAMAL.app.remove_proxy_app_directory, raise_on_non_zero_exit: false
+      end
+    end
+  end
+
+  desc "version", "Show app version currently running on servers"
+  def version
+    quiet = options[:quiet]
+    on(KAMAL.app_hosts) do |host|
+      role = KAMAL.roles_on(host).first
+      puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).current_running_version).strip, quiet: quiet
+    end
+  end
+
+  private
+    def hosts_removing_all_roles
+      KAMAL.app_hosts.select { |host| KAMAL.roles_on(host).map(&:name).sort == KAMAL.config.host_roles(host.to_s).map(&:name).sort }
+    end
+
+    def using_version(new_version)
+      if new_version
+        begin
+          old_version = KAMAL.config.version
+          KAMAL.config.version = new_version
+          yield new_version
+        ensure
+          KAMAL.config.version = old_version
+        end
+      else
+        yield KAMAL.config.version
+      end
+    end
+
+    def current_running_version(host: KAMAL.primary_host)
+      version = nil
+      on(host) do
+        role = KAMAL.roles_on(host).first
+        version = capture_with_info(*KAMAL.app(role: role, host: host).current_running_version).strip
+      end
+      version.presence
+    end
+
+    def version_or_latest
+      options[:version] || KAMAL.config.latest_tag
+    end
+
+    def with_lock_if_stopping
+      if options[:stop]
+        modify(lock: true) { yield }
+      else
+        yield
+      end
+    end
+
+    def host_boot_groups
+      KAMAL.config.boot.limit ? KAMAL.app_hosts.each_slice(KAMAL.config.boot.limit).to_a : [ KAMAL.app_hosts ]
+    end
+end

data/lib/kamal/cli/base.rb

@@ -0,0 +1,324 @@
+require "thor"
+require "kamal/sshkit_with_ext"
+
+module Kamal::Cli
+  class Base < Thor
+    include SSHKit::DSL
+
+    VERBOSITY = { verbose: :debug, quiet: :error }.freeze
+    AUTOMATIC_DEPLOY_LOCK_MESSAGE = "Automatic deploy lock"
+
+    class LockHeldError < StandardError; end
+    class LockMissingError < StandardError; end
+
+    def self.exit_on_failure?() true end
+    def self.dynamic_command_class() Kamal::Cli::Alias::Command end
+
+    class_option :verbose, type: :boolean, aliases: "-v", desc: "Detailed logging"
+    class_option :quiet, type: :boolean, aliases: "-q", desc: "Minimal logging"
+
+    class_option :version, desc: "Run commands against a specific app version"
+
+    class_option :primary, type: :boolean, aliases: "-p", desc: "Run commands only on primary host instead of all"
+    class_option :hosts, aliases: "-h", desc: "Run commands on these hosts instead of all (separate by comma, supports wildcards with *)"
+    class_option :roles, aliases: "-r", desc: "Run commands on these roles instead of all (separate by comma, supports wildcards with *)"
+
+    class_option :config_file, aliases: "-c", default: "config/deploy.yml", desc: "Path to config file"
+    class_option :destination, aliases: "-d", desc: "Specify destination to be used for config file (staging -> deploy.staging.yml)"
+
+    class_option :skip_hooks, aliases: "-H", type: :boolean, default: false, desc: "Don't run hooks"
+
+    class_option :lock_wait, type: :boolean, default: false, desc: "Wait for the deploy lock if it's already held instead of failing immediately"
+    class_option :lock_wait_timeout, type: :numeric, default: 900, desc: "Maximum seconds to wait for the deploy lock when --lock-wait is set"
+    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)
+        # 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)
+      else
+        super
+      end
+
+      initialize_commander unless KAMAL.configured?
+    end
+
+    private
+      def options_with_subcommand_class_options
+        options.merge(@_initializer.last[:class_options] || {})
+      end
+
+      def initialize_commander
+        KAMAL.tap do |commander|
+          if options[:verbose]
+            ENV["VERBOSE"] = "1" # For backtraces via cli/start
+            commander.verbosity = VERBOSITY[:verbose]
+          end
+
+          if options[:quiet]
+            commander.verbosity = VERBOSITY[:quiet]
+          end
+
+          commander.configure \
+            config_file: Pathname.new(File.expand_path(options[:config_file])),
+            destination: options[:destination],
+            version: options[:version]
+
+          commander.specific_hosts    = options[:hosts]&.split(",")
+          commander.specific_roles    = options[:roles]&.split(",")
+          commander.specific_primary! if options[:primary]
+
+          commander.lock_wait          = options[:lock_wait]
+          commander.lock_wait_timeout  = options[:lock_wait_timeout]
+          commander.lock_wait_interval = options[:lock_wait_interval]
+        end
+      end
+
+      def print_runtime
+        started_at = Time.now
+        yield
+        Time.now - started_at
+      ensure
+        runtime = Time.now - started_at
+        puts "  Finished all in #{sprintf("%.1f seconds", runtime)}"
+      end
+
+      def modify(lock: false)
+        KAMAL.modify(command: command, subcommand: subcommand) do
+          lock ? with_lock { yield } : yield
+        end
+      end
+
+      def say(message = "", *)
+        super unless options[:raw]
+        KAMAL.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
+      end
+
+      def with_lock
+        if KAMAL.holding_lock?
+          yield
+        else
+          acquire_lock
+
+          begin
+            yield
+          rescue
+            begin
+              release_lock
+            rescue => e
+              say "Error releasing the deploy lock: #{e.message}", :red
+            end
+            raise
+          end
+
+          release_lock
+        end
+      end
+
+      def confirming(question)
+        return yield if options[:confirmed]
+
+        if ask(question, limited_to: %w[ y N ], default: "N") == "y"
+          yield
+        else
+          say "Aborted", :red
+        end
+      end
+
+      def acquire_lock
+        ensure_run_directory
+
+        if KAMAL.lock_wait
+          acquire_lock_with_wait
+        else
+          raise_if_locked do
+            say "Acquiring the deploy lock...", :magenta
+            execute_lock_acquire(AUTOMATIC_DEPLOY_LOCK_MESSAGE)
+          end
+        end
+
+        KAMAL.holding_lock = true
+      end
+
+      def acquire_lock_with_wait
+        timeout = KAMAL.lock_wait_timeout
+        interval = KAMAL.lock_wait_interval
+        deadline = Time.now + timeout
+        details_shown = false
+
+        say "Acquiring the deploy lock (waiting up to #{timeout}s)...", :magenta
+
+        loop do
+          execute_lock_acquire(AUTOMATIC_DEPLOY_LOCK_MESSAGE)
+          break
+        rescue LockHeldError
+          unless details_shown
+            status = capture_lock_status
+
+            say "Deploy lock is held by:", :magenta
+            puts status
+
+            unless status.include?(AUTOMATIC_DEPLOY_LOCK_MESSAGE)
+              raise LockError, "Deploy lock held manually, not waiting. Run 'kamal lock help' for more information"
+            end
+
+            details_shown = true
+          end
+
+          remaining = (deadline - Time.now).to_i
+          if remaining <= 0
+            say "Timed out after #{timeout}s waiting for the deploy lock", :red
+            raise LockError, "Timed out waiting for deploy lock"
+          end
+
+          say "Retrying in #{interval}s (#{remaining}s remaining)...", :magenta
+          sleep [ interval, remaining ].min
+        end
+      end
+
+      def release_lock
+        say "Releasing the deploy lock...", :magenta
+        execute_lock_release
+
+        KAMAL.holding_lock = false
+      end
+
+      def raise_if_locked
+        yield
+      rescue LockHeldError
+        say "Deploy lock already in place!", :red
+        puts capture_lock_status
+        raise LockError, "Deploy lock found. Run 'kamal lock help' for more information"
+      end
+
+      def execute_lock_acquire(message)
+        on(KAMAL.primary_host) { execute *KAMAL.lock.acquire(message, KAMAL.config.version), verbosity: :debug }
+      rescue SSHKit::Runner::ExecuteError => e
+        raise LockHeldError if e.message =~ /cannot create directory/
+        raise
+      end
+
+      def execute_lock_release
+        on(KAMAL.primary_host) { execute *KAMAL.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
+        status = nil
+        on(KAMAL.primary_host) { status = capture_with_debug(*KAMAL.lock.status) }
+        status
+      rescue SSHKit::Runner::ExecuteError => e
+        raise LockMissingError if e.message =~ /No such file or directory/
+        raise
+      end
+
+      def run_hook(hook, **extra_details)
+        if !options[:skip_hooks] && KAMAL.hook.hook_exists?(hook)
+          details = {
+            hosts: KAMAL.hosts.join(","),
+            roles: KAMAL.specific_roles&.join(","),
+            lock: KAMAL.holding_lock?.to_s,
+            command: command,
+            subcommand: subcommand
+          }.compact
+
+          hooks_output = KAMAL.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
+            VERBOSITY.fetch(hooks_output)
+          else
+            KAMAL.verbosity
+          end
+
+          with_env KAMAL.hook.env(**details, **extra_details) do
+            KAMAL.with_verbosity(hook_verbosity) do
+              run_locally do
+                execute *KAMAL.hook.run(hook)
+              end
+            end
+          rescue SSHKit::Command::Failed => e
+            raise HookError.new("Hook `#{hook}` failed:\n#{e.message}")
+          end
+        end
+      end
+
+      def on(*args, &block)
+        pre_connect_if_required
+
+        super
+      end
+
+      def pre_connect_if_required
+        if !KAMAL.connected?
+          run_hook "pre-connect", secrets: true unless options[:skip_hooks]
+          KAMAL.connected = true
+        end
+      end
+
+      def command
+        @kamal_command ||= begin
+          invocation_class, invocation_commands = *first_invocation
+          if invocation_class == Kamal::Cli::Main
+            invocation_commands[0]
+          else
+            Kamal::Cli::Main.subcommand_classes.find { |command, clazz| clazz == invocation_class }[0]
+          end
+        end
+      end
+
+      def subcommand
+        @kamal_subcommand ||= begin
+          invocation_class, invocation_commands = *first_invocation
+          invocation_commands[0] if invocation_class != Kamal::Cli::Main
+        end
+      end
+
+      def first_invocation
+        instance_variable_get("@_invocations").first
+      end
+
+      def reset_invocation(cli_class)
+        instance_variable_get("@_invocations")[cli_class].pop
+      end
+
+      def ensure_run_directory
+        on(KAMAL.hosts) do
+          execute(*KAMAL.server.ensure_run_directory)
+        end
+      end
+
+      def with_env(env)
+        current_env = ENV.to_h.dup
+        ENV.update(env)
+        yield
+      ensure
+        ENV.clear
+        ENV.update(current_env)
+      end
+
+      def ensure_docker_installed
+        run_locally do
+          begin
+            execute *KAMAL.builder.ensure_docker_installed
+          rescue SSHKit::Command::Failed => e
+            error = e.message =~ /command not found/ ?
+              "Docker is not installed locally" :
+              "Docker buildx plugin is not installed locally"
+
+            raise DependencyError, error
+          end
+        end
+      end
+  end
+end