Bump version for 0.16.0

Rename project to Kamal

.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+on: 
+  push:
+    branches:
+      - main
+  pull_request:
+jobs:
+  tests:
+    strategy:
+      matrix:
+        ruby-version:
+          - "2.7"
+          - "3.1"
+          - "3.2"
+        gemfile:
+          - Gemfile
+          - gemfiles/rails_edge.gemfile
+        continue-on-error: [false]
+    name: ${{ format('Tests (Ruby {0})', matrix.ruby-version) }}
+    runs-on: ubuntu-latest
+    continue-on-error: ${{ matrix.continue-on-error }}
+    env:
+      BUNDLE_GEMFILE: ${{ github.workspace }}/${{ matrix.gemfile }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+
+      - name: Run tests
+        run: bin/test

.github/workflows/docker-publish.yml

@@ -0,0 +1,41 @@
+name: Docker
+
+on:
+  release:
+    types: [created]
+    tags:
+      - 'v*'
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@v3
+      -
+        name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      -
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      -
+        name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      -
+        name: Build and push
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            ghcr.io/mrsked/mrsk:latest
+            ghcr.io/mrsked/mrsk:${{ github.ref_name }}

.gitignore

@@ -1,2 +1,5 @@
 .byebug_history
 *.gem
+coverage/*
+.DS_Store
+gemfiles/*.lock

CODE_OF_CONDUCT.md

@@ -0,0 +1,41 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of the Kamal project, we pledge to create a welcoming and inclusive environment for everyone. We value the participation of each member of our community and want all contributors to feel respected and valued.
+
+We are committed to providing a harassment-free experience for everyone, regardless of gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, age, or religion (or lack thereof). We do not tolerate harassment of participants in any form.
+
+This code of conduct applies to all Kamal project spaces, including but not limited to project code, issue trackers, chat rooms, and mailing lists. Violations of this code of conduct may result in removal from the project community.
+
+## Our standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+- The use of sexualized language or imagery and unwelcome sexual attention or advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned with this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Reporting
+
+If you are subject to or witness unacceptable behavior, or have any other concerns, please notify a project maintainer. All reports will be kept confidential and will be reviewed and investigated promptly.
+
+We will investigate every complaint and take appropriate action. We reserve the right to remove any content that violates this Code of Conduct, or to temporarily or permanently ban any contributor for other behaviors that we deem inappropriate, threatening, offensive, or harmful.
+
+## Attribution
+
+This Code of Conduct is adapted from the Contributor Covenant, version 1.4, available at <https://www.contributor-covenant.org/version/1/4/code-of-conduct.html>.

CONTRIBUTING.md

@@ -0,0 +1,49 @@
+# Contributing to Kamal development
+
+Thank you for considering contributing to Kamal! This document outlines some guidelines for contributing to this open source project.
+
+Please make sure to review our [Code of Conduct](CODE_OF_CONDUCT.md) before contributing to Kamal.
+
+There are several ways you can contribute to the betterment of the project:
+
+- **Report an issue?** - If the issue isn’t reported, we can’t fix it. Please report any bugs, feature, and/or improvement requests on the [Kamal GitHub Issues tracker](https://github.com/basecamp/kamal/issues).
+- **Submit patches** - Do you have a new feature or a fix you'd like to share? [Submit a pull request](https://github.com/basecamp/kamal/pulls)!
+- **Write blog articles** - Are you using Kamal? We'd love to hear how you're using it with your projects. Write a tutorial and post it on your blog!
+
+## Issues
+
+If you encounter any issues with the project, please check the [existing issues](https://github.com/basecamp/kamal/issues) first to see if the issue has already been reported. If the issue hasn't been reported, please open a new issue with a clear description of the problem and steps to reproduce it.
+
+## Pull Requests
+
+Please keep the following guidelines in mind when opening a pull request:
+
+- Ensure that your code passes the project's minitests by running ./bin/test.
+- Provide a clear and detailed description of your changes.
+- Keep your changes focused on a single concern.
+- Write clean and readable code that follows the project's code style.
+- Use descriptive variable and function names.
+- Write clear and concise commit messages.
+- Add tests for your changes, if possible.
+- Ensure that your changes don't break existing functionality.
+
+#### Commit message guidelines
+
+A good commit message should describe what changed and why.
+
+## Development
+
+The `main` branch is regularly built and tested, but it is not guaranteed to be completely stable. Tags are created regularly from release branches to indicate new official, stable release versions of Kamal.
+
+Kamal is written in Ruby. You should have Ruby 3.2+ installed on your machine in order to work on Kamal. If that's already setup, run `bundle` in the root directory to install all dependencies. Then you can run `bin/test` to run all tests.
+
+1. Fork the project repository.
+2. Create a new branch for your contribution.
+3. Write your code or make the desired changes.
+4. **Ensure that your code passes the project's minitests by running ./bin/test.**
+5. Commit your changes and push them to your forked repository.
+6. [Open a pull request](https://github.com/basecamp/kamal/pulls) to the main project repository with a detailed description of your changes.
+
+## License
+
+Kamal is released under the MIT License. By contributing to this project, you agree to license your contributions under the same license.

Dockerfile

@@ -0,0 +1,40 @@
+# Use the official Ruby 3.2.0 Alpine image as the base image
+FROM ruby:3.2.0-alpine
+
+# Install  docker/buildx-bin
+COPY --from=docker/buildx-bin /buildx /usr/libexec/docker/cli-plugins/docker-buildx
+
+# Set the working directory to /kamal
+WORKDIR /kamal
+
+# Copy the Gemfile, Gemfile.lock into the container
+COPY Gemfile Gemfile.lock kamal.gemspec ./
+
+# Required in kamal.gemspec
+COPY lib/kamal/version.rb /kamal/lib/kamal/version.rb
+
+# Install system dependencies
+RUN apk add --no-cache --update build-base git docker openrc openssh-client-default \
+    && rc-update add docker boot \
+    && gem install bundler --version=2.4.3 \
+    && bundle install
+
+# Copy the rest of our application code into the container.
+# We do this after bundle install, to avoid having to run bundle
+# every time we do small fixes in the source code.
+COPY . .
+
+# Install the gem locally from the project folder
+RUN gem build kamal.gemspec && \
+    gem install ./kamal-*.gem --no-document
+
+# Set the working directory to /workdir
+WORKDIR /workdir
+
+# Tell git it's safe to access /workdir/.git even if
+# the directory is owned by a different user
+RUN git config --global --add safe.directory /workdir
+
+# Set the entrypoint to run the installed binary in /workdir
+# Example:  docker run -it -v "$PWD:/workdir" kamal init
+ENTRYPOINT ["kamal"]

Gemfile

@@ -1,9 +1,4 @@
 source 'https://rubygems.org'
 git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
-# Specify your gem's dependencies in importmap-rails.gemspec.
 gemspec
-
-group :test do
-  gem "byebug"
-end

Gemfile.lock

@@ -1,84 +1,107 @@
 PATH
   remote: .
   specs:
-    mrsk (0.0.1)
-      railties (>= 7.0.0)
+    kamal (0.16.0)
+      activesupport (>= 7.0)
+      bcrypt_pbkdf (~> 1.0)
+      concurrent-ruby (~> 1.2)
+      dotenv (~> 2.8)
+      ed25519 (~> 1.2)
+      net-ssh (~> 7.0)
       sshkit (~> 1.21)
+      thor (~> 1.2)
+      zeitwerk (~> 2.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    actionpack (7.0.4)
-      actionview (= 7.0.4)
-      activesupport (= 7.0.4)
+    actionpack (7.0.4.3)
+      actionview (= 7.0.4.3)
+      activesupport (= 7.0.4.3)
       rack (~> 2.0, >= 2.2.0)
       rack-test (>= 0.6.3)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.0, >= 1.2.0)
-    actionview (7.0.4)
-      activesupport (= 7.0.4)
+    actionview (7.0.4.3)
+      activesupport (= 7.0.4.3)
       builder (~> 3.1)
       erubi (~> 1.4)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.1, >= 1.2.0)
-    activesupport (7.0.4)
+    activesupport (7.0.4.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
+    bcrypt_pbkdf (1.1.0)
     builder (3.2.4)
-    byebug (11.1.3)
-    concurrent-ruby (1.1.10)
+    concurrent-ruby (1.2.2)
     crass (1.0.6)
+    debug (1.7.2)
+      irb (>= 1.5.0)
+      reline (>= 0.3.1)
+    dotenv (2.8.1)
+    ed25519 (1.3.0)
     erubi (1.12.0)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
-    loofah (2.19.1)
+    io-console (0.6.0)
+    irb (1.6.3)
+      reline (>= 0.3.0)
+    loofah (2.20.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     method_source (1.0.0)
-    minitest (5.17.0)
+    minitest (5.18.0)
+    mocha (2.0.2)
+      ruby2_keywords (>= 0.0.5)
     net-scp (4.0.0)
       net-ssh (>= 2.6.5, < 8.0.0)
-    net-ssh (7.0.1)
-    nokogiri (1.13.10-arm64-darwin)
+    net-ssh (7.1.0)
+    nokogiri (1.14.2-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.14.2-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.14.2-x86_64-linux)
       racc (~> 1.4)
     racc (1.6.2)
-    rack (2.2.5)
-    rack-test (2.0.2)
+    rack (2.2.6.4)
+    rack-test (2.1.0)
       rack (>= 1.3)
     rails-dom-testing (2.0.3)
       activesupport (>= 4.2.0)
       nokogiri (>= 1.6)
-    rails-html-sanitizer (1.4.4)
+    rails-html-sanitizer (1.5.0)
       loofah (~> 2.19, >= 2.19.1)
-    railties (7.0.4)
-      actionpack (= 7.0.4)
-      activesupport (= 7.0.4)
+    railties (7.0.4.3)
+      actionpack (= 7.0.4.3)
+      activesupport (= 7.0.4.3)
       method_source
       rake (>= 12.2)
       thor (~> 1.0)
       zeitwerk (~> 2.5)
     rake (13.0.6)
-    sshkit (1.21.3)
+    reline (0.3.3)
+      io-console (~> 0.5)
+    ruby2_keywords (0.0.5)
+    sshkit (1.21.4)
       net-scp (>= 1.1.2)
       net-ssh (>= 2.8.0)
     thor (1.2.1)
-    tzinfo (2.0.5)
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    zeitwerk (2.6.6)
+    zeitwerk (2.6.7)
 
 PLATFORMS
-  arm64-darwin-20
-  arm64-darwin-21
-  arm64-darwin-22
-  x86_64-darwin-20
-  x86_64-darwin-21
+  arm64-darwin
+  x86_64-darwin
   x86_64-linux
 
 DEPENDENCIES
-  byebug
-  mrsk!
+  debug
+  kamal!
+  mocha
+  railties
 
 BUNDLED WITH
-   2.2.33
+   2.4.3

bin/kamal

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+# Prevent failures from being reported twice.
+Thread.report_on_exception = false
+
+require "kamal"
+
+begin
+  Kamal::Cli::Main.start(ARGV)
+rescue SSHKit::Runner::ExecuteError => e
+  puts "  \e[31mERROR (#{e.cause.class}): #{e.message}\e[0m"
+  puts e.cause.backtrace if ENV["VERBOSE"]
+  exit 1
+rescue => e
+  puts "  \e[31mERROR (#{e.class}): #{e.message}\e[0m"
+  puts e.backtrace if ENV["VERBOSE"]
+  exit 1
+end

bin/release

@@ -2,13 +2,13 @@
 
 VERSION=$1
 
-printf "module Mrsk\n  VERSION = \"$VERSION\"\nend\n" > ./lib/mrsk/version.rb
+printf "module Kamal\n  VERSION = \"$VERSION\"\nend\n" > ./lib/kamal/version.rb
 bundle
-git add Gemfile.lock lib/mrsk/version.rb
+git add Gemfile.lock lib/kamal/version.rb
 git commit -m "Bump version for $VERSION"
 git push
 git tag v$VERSION
 git push --tags
-gem build mrsk.gemspec
-gem push "mrsk-$VERSION.gem" --host https://rubygems.org
-rm "mrsk-$VERSION.gem"
+gem build kamal.gemspec
+gem push "kamal-$VERSION.gem" --host https://rubygems.org
+rm "kamal-$VERSION.gem"

gemfiles/rails_edge.gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+git "https://github.com/rails/rails.git" do
+  gem "railties"
+  gem "activesupport"
+end
+
+gemspec path: "../"

kamal.gemspec

@@ -0,0 +1,28 @@
+require_relative "lib/kamal/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "kamal"
+  spec.version     = Kamal::VERSION
+  spec.authors     = [ "David Heinemeier Hansson" ]
+  spec.email       = "dhh@hey.com"
+  spec.homepage    = "https://github.com/rails/kamal"
+  spec.summary     = "Deploy web apps in containers to servers running Docker with zero downtime."
+  spec.license     = "MIT"
+
+  spec.files = Dir["lib/**/*", "MIT-LICENSE", "README.md"]
+  spec.executables = %w[ kamal ]
+
+  spec.add_dependency "activesupport", ">= 7.0"
+  spec.add_dependency "sshkit", "~> 1.21"
+  spec.add_dependency "net-ssh", "~> 7.0"
+  spec.add_dependency "thor", "~> 1.2"
+  spec.add_dependency "dotenv", "~> 2.8"
+  spec.add_dependency "zeitwerk", "~> 2.5"
+  spec.add_dependency "ed25519", "~> 1.2"
+  spec.add_dependency "bcrypt_pbkdf", "~> 1.0"
+  spec.add_dependency "concurrent-ruby", "~> 1.2"
+
+  spec.add_development_dependency "debug"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "railties"
+end

lib/kamal.rb

@@ -0,0 +1,10 @@
+module Kamal
+end
+
+require "active_support"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/kamal/sshkit_with_ext.rb")
+loader.setup
+loader.eager_load # We need all commands loaded.

lib/kamal/cli.rb

@@ -0,0 +1,7 @@
+module Kamal::Cli
+  class LockError < StandardError; end
+  class HookError < StandardError; end
+end
+
+# SSHKit uses instance eval, so we need a global const for ergonomics
+KAMAL = Kamal::Commander.new

lib/kamal/cli/accessory.rb

@@ -0,0 +1,239 @@
+class Kamal::Cli::Accessory < Kamal::Cli::Base
+  desc "boot [NAME]", "Boot new accessory service on host (use NAME=all to boot all accessories)"
+  def boot(name, login: true)
+    mutating do
+      if name == "all"
+        KAMAL.accessory_names.each { |accessory_name| boot(accessory_name) }
+      else
+        with_accessory(name) do |accessory|
+          directories(name)
+          upload(name)
+
+          on(accessory.hosts) do
+            execute *KAMAL.registry.login if login
+            execute *KAMAL.auditor.record("Booted #{name} accessory"), verbosity: :debug
+            execute *accessory.run
+          end
+        end
+      end
+    end
+  end
+
+  desc "upload [NAME]", "Upload accessory files to host", hide: true
+  def upload(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          accessory.files.each do |(local, remote)|
+            accessory.ensure_local_file_present(local)
+
+            execute *accessory.make_directory_for(remote)
+            upload! local, remote
+            execute :chmod, "755", remote
+          end
+        end
+      end
+    end
+  end
+
+  desc "directories [NAME]", "Create accessory directories on host", hide: true
+  def directories(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          accessory.directories.keys.each do |host_path|
+            execute *accessory.make_directory(host_path)
+          end
+        end
+      end
+    end
+  end
+
+  desc "reboot [NAME]", "Reboot existing accessory on host (stop container, remove container, start new container)"
+  def reboot(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *KAMAL.registry.login
+        end
+
+        stop(name)
+        remove_container(name)
+        boot(name, login: false)
+      end
+    end
+  end
+
+  desc "start [NAME]", "Start existing accessory container on host"
+  def start(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *KAMAL.auditor.record("Started #{name} accessory"), verbosity: :debug
+          execute *accessory.start
+        end
+      end
+    end
+  end
+
+  desc "stop [NAME]", "Stop existing accessory container on host"
+  def stop(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *KAMAL.auditor.record("Stopped #{name} accessory"), verbosity: :debug
+          execute *accessory.stop, raise_on_non_zero_exit: false
+        end
+      end
+    end
+  end
+
+  desc "restart [NAME]", "Restart existing accessory container on host"
+  def restart(name)
+    mutating do
+      with_accessory(name) do
+        stop(name)
+        start(name)
+      end
+    end
+  end
+
+  desc "details [NAME]", "Show details about accessory on host (use NAME=all to show all accessories)"
+  def details(name)
+    if name == "all"
+      KAMAL.accessory_names.each { |accessory_name| details(accessory_name) }
+    else
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) { puts capture_with_info(*accessory.info) }
+      end
+    end
+  end
+
+  desc "exec [NAME] [CMD]", "Execute a custom command on servers (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"
+  def exec(name, cmd)
+    with_accessory(name) do |accessory|
+      case
+      when options[:interactive] && options[:reuse]
+        say "Launching interactive command with via SSH from existing container...", :magenta
+        run_locally { exec accessory.execute_in_existing_container_over_ssh(cmd) }
+
+      when options[:interactive]
+        say "Launching interactive command via SSH from new container...", :magenta
+        run_locally { exec accessory.execute_in_new_container_over_ssh(cmd) }
+
+      when options[:reuse]
+        say "Launching command from existing container...", :magenta
+        on(accessory.hosts) do
+          execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on #{name} accessory"), verbosity: :debug
+          capture_with_info(*accessory.execute_in_existing_container(cmd))
+        end
+
+      else
+        say "Launching command from new container...", :magenta
+        on(accessory.hosts) do
+          execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on #{name} accessory"), verbosity: :debug
+          capture_with_info(*accessory.execute_in_new_container(cmd))
+        end
+      end
+    end
+  end
+
+  desc "logs [NAME]", "Show log lines from accessory on host (use --help to show options)"
+  option :since, aliases: "-s", desc: "Show logs 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 log lines to pull from each server"
+  option :grep, aliases: "-g", desc: "Show lines with grep match only (use this to fetch specific requests by id)"
+  option :follow, aliases: "-f", desc: "Follow logs on primary server (or specific host set by --hosts)"
+  def logs(name)
+    with_accessory(name) do |accessory|
+      grep = options[:grep]
+
+      if options[:follow]
+        run_locally do
+          info "Following logs on #{accessory.hosts}..."
+          info accessory.follow_logs(grep: grep)
+          exec accessory.follow_logs(grep: grep)
+        end
+      else
+        since = options[:since]
+        lines = options[:lines].presence || ((since || grep) ? nil : 100) # Default to 100 lines if since or grep isn't set
+
+        on(accessory.hosts) do
+          puts capture_with_info(*accessory.logs(since: since, lines: lines, grep: grep))
+        end
+      end
+    end
+  end
+
+  desc "remove [NAME]", "Remove accessory container, image and data directory from host (use NAME=all to remove all accessories)"
+  option :confirmed, aliases: "-y", type: :boolean, default: false, desc: "Proceed without confirmation question"
+  def remove(name)
+    mutating do
+      if name == "all"
+        KAMAL.accessory_names.each { |accessory_name| remove(accessory_name) }
+      else
+        if options[:confirmed] || ask("This will remove all containers, images and data directories for #{name}. Are you sure?", limited_to: %w( y N ), default: "N") == "y"
+          with_accessory(name) do
+            stop(name)
+            remove_container(name)
+            remove_image(name)
+            remove_service_directory(name)
+          end
+        end
+      end
+    end
+  end
+
+  desc "remove_container [NAME]", "Remove accessory container from host", hide: true
+  def remove_container(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *KAMAL.auditor.record("Remove #{name} accessory container"), verbosity: :debug
+          execute *accessory.remove_container
+        end
+      end
+    end
+  end
+
+  desc "remove_image [NAME]", "Remove accessory image from host", hide: true
+  def remove_image(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *KAMAL.auditor.record("Removed #{name} accessory image"), verbosity: :debug
+          execute *accessory.remove_image
+        end
+      end
+    end
+  end
+
+  desc "remove_service_directory [NAME]", "Remove accessory directory used for uploaded files and data directories from host", hide: true
+  def remove_service_directory(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *accessory.remove_service_directory
+        end
+      end
+    end
+  end
+
+  private
+    def with_accessory(name)
+      if accessory = KAMAL.accessory(name)
+        yield accessory
+      else
+        error_on_missing_accessory(name)
+      end
+    end
+
+    def error_on_missing_accessory(name)
+      options = KAMAL.accessory_names.presence
+
+      error \
+        "No accessory by the name of '#{name}'" +
+        (options ? " (options: #{options.to_sentence})" : "")
+    end
+end

lib/kamal/cli/app.rb

@@ -0,0 +1,296 @@
+class Kamal::Cli::App < Kamal::Cli::Base
+  desc "boot", "Boot app on servers (or reboot app if already running)"
+  def boot
+    mutating do
+      hold_lock_on_error 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} using a #{KAMAL.config.readiness_delay}s readiness delay (or reboot if already running)...", :magenta
+
+          on(KAMAL.hosts) do
+            execute *KAMAL.auditor.record("Tagging #{KAMAL.config.absolute_image} as the latest image"), verbosity: :debug
+            execute *KAMAL.app.tag_current_as_latest
+          end
+
+          on(KAMAL.hosts, **KAMAL.boot_strategy) do |host|
+            roles = KAMAL.roles_on(host)
+
+            roles.each do |role|
+              app = KAMAL.app(role: role)
+              auditor = KAMAL.auditor(role: role)
+
+              if capture_with_info(*app.container_id_for_version(version, only_running: true), raise_on_non_zero_exit: false).present?
+                tmp_version = "#{version}_replaced_#{SecureRandom.hex(8)}"
+                info "Renaming container #{version} to #{tmp_version} as already deployed on #{host}"
+                execute *auditor.record("Renaming container #{version} to #{tmp_version}"), verbosity: :debug
+                execute *app.rename_container(version: version, new_version: tmp_version)
+              end
+
+              execute *auditor.record("Booted app version #{version}"), verbosity: :debug
+
+              old_version = capture_with_info(*app.current_running_version, raise_on_non_zero_exit: false).strip
+              execute *app.start_or_run(hostname: "#{host}-#{SecureRandom.hex(6)}")
+
+              Kamal::Utils::HealthcheckPoller.wait_for_healthy(pause_after_ready: true) { capture_with_info(*app.status(version: version)) }
+
+              execute *app.stop(version: old_version), raise_on_non_zero_exit: false if old_version.present?
+            end
+          end
+        end
+      end
+    end
+  end
+
+  desc "start", "Start existing app container on servers"
+  def start
+    mutating do
+      on(KAMAL.hosts) do |host|
+        roles = KAMAL.roles_on(host)
+
+        roles.each do |role|
+          execute *KAMAL.auditor.record("Started app version #{KAMAL.config.version}"), verbosity: :debug
+          execute *KAMAL.app(role: role).start, raise_on_non_zero_exit: false
+        end
+      end
+    end
+  end
+
+  desc "stop", "Stop app container on servers"
+  def stop
+    mutating do
+      on(KAMAL.hosts) do |host|
+        roles = KAMAL.roles_on(host)
+
+        roles.each do |role|
+          execute *KAMAL.auditor.record("Stopped app", role: role), verbosity: :debug
+          execute *KAMAL.app(role: role).stop, raise_on_non_zero_exit: false
+        end
+      end
+    end
+  end
+
+  # FIXME: Drop in favor of just containers?
+  desc "details", "Show details about app containers"
+  def details
+    on(KAMAL.hosts) do |host|
+      roles = KAMAL.roles_on(host)
+
+      roles.each do |role|
+        puts_by_host host, capture_with_info(*KAMAL.app(role: role).info)
+      end
+    end
+  end
+
+  desc "exec [CMD]", "Execute a custom command on servers (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"
+  def exec(cmd)
+    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: "web").execute_in_existing_container_over_ssh(cmd, host: KAMAL.primary_host) }
+      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
+        run_locally { exec KAMAL.app(role: KAMAL.primary_host.roles.first).execute_in_new_container_over_ssh(cmd, host: KAMAL.primary_host) }
+      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(KAMAL.hosts) do |host|
+          roles = KAMAL.roles_on(host)
+
+          roles.each do |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).execute_in_existing_container(cmd))
+          end
+        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.hosts) do |host|
+          execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on app version #{version}"), verbosity: :debug
+          puts_by_host host, capture_with_info(*KAMAL.app.execute_in_new_container(cmd))
+        end
+      end
+    end
+  end
+
+  desc "containers", "Show app containers on servers"
+  def containers
+    on(KAMAL.hosts) { |host| puts_by_host host, capture_with_info(*KAMAL.app.list_containers) }
+  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
+    mutating do
+      stop = options[:stop]
+
+      cli = self
+
+      on(KAMAL.hosts) do |host|
+        roles = KAMAL.roles_on(host)
+
+        roles.each do |role|
+          cli.send(:stale_versions, host: host, role: role).each do |version|
+            if stop
+              puts_by_host host, "Stopping stale container for role #{role} with version #{version}"
+              execute *KAMAL.app(role: role).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)"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  desc "images", "Show app images on servers"
+  def images
+    on(KAMAL.hosts) { |host| puts_by_host host, capture_with_info(*KAMAL.app.list_images) }
+  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 :follow, aliases: "-f", desc: "Follow log on primary server (or specific host set by --hosts)"
+  def logs
+    # FIXME: Catch when app containers aren't running
+
+    grep = options[:grep]
+
+    if options[:follow]
+      run_locally do
+        info "Following logs on #{KAMAL.primary_host}..."
+
+        KAMAL.specific_roles ||= ["web"]
+        role = KAMAL.roles_on(KAMAL.primary_host).first
+
+        info KAMAL.app(role: role).follow_logs(host: KAMAL.primary_host, grep: grep)
+        exec KAMAL.app(role: role).follow_logs(host: KAMAL.primary_host, grep: grep)
+      end
+    else
+      since = options[:since]
+      lines = options[:lines].presence || ((since || grep) ? nil : 100) # Default to 100 lines if since or grep isn't set
+
+      on(KAMAL.hosts) do |host|
+        roles = KAMAL.roles_on(host)
+
+        roles.each do |role|
+          begin
+            puts_by_host host, capture_with_info(*KAMAL.app(role: role).logs(since: since, lines: lines, grep: grep))
+          rescue SSHKit::Command::Failed
+            puts_by_host host, "Nothing found"
+          end
+        end
+      end
+    end
+  end
+
+  desc "remove", "Remove app containers and images from servers"
+  def remove
+    mutating do
+      stop
+      remove_containers
+      remove_images
+    end
+  end
+
+  desc "remove_container [VERSION]", "Remove app container with given version from servers", hide: true
+  def remove_container(version)
+    mutating do
+      on(KAMAL.hosts) do |host|
+        roles = KAMAL.roles_on(host)
+
+        roles.each do |role|
+          execute *KAMAL.auditor.record("Removed app container with version #{version}", role: role), verbosity: :debug
+          execute *KAMAL.app(role: role).remove_container(version: version)
+        end
+      end
+    end
+  end
+
+  desc "remove_containers", "Remove all app containers from servers", hide: true
+  def remove_containers
+    mutating do
+      on(KAMAL.hosts) do |host|
+        roles = KAMAL.roles_on(host)
+
+        roles.each do |role|
+          execute *KAMAL.auditor.record("Removed all app containers", role: role), verbosity: :debug
+          execute *KAMAL.app(role: role).remove_containers
+        end
+      end
+    end
+  end
+
+  desc "remove_images", "Remove all app images from servers", hide: true
+  def remove_images
+    mutating do
+      on(KAMAL.hosts) do
+        execute *KAMAL.auditor.record("Removed all app images"), verbosity: :debug
+        execute *KAMAL.app.remove_images
+      end
+    end
+  end
+
+  desc "version", "Show app version currently running on servers"
+  def version
+    on(KAMAL.hosts) do |host|
+      role = KAMAL.roles_on(host).first
+      puts_by_host host, capture_with_info(*KAMAL.app(role: role).current_running_version).strip
+    end
+  end
+
+  private
+    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).current_running_version).strip
+      end
+      version.presence
+    end
+
+    def stale_versions(host:, role:)
+      versions = nil
+      on(host) do
+        versions = \
+          capture_with_info(*KAMAL.app(role: role).list_versions, raise_on_non_zero_exit: false)
+          .split("\n")
+          .drop(1)
+      end
+      versions
+    end
+
+    def version_or_latest
+      options[:version] || "latest"
+    end
+end

lib/kamal/cli/base.rb

@@ -0,0 +1,171 @@
+require "thor"
+require "dotenv"
+require "kamal/sshkit_with_ext"
+
+module Kamal::Cli
+  class Base < Thor
+    include SSHKit::DSL
+
+    def self.exit_on_failure?() true 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)"
+    class_option :roles, aliases: "-r", desc: "Run commands on these roles instead of all (separate by comma)"
+
+    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"
+
+    def initialize(*)
+      super
+      load_envs
+      initialize_commander(options_with_subcommand_class_options)
+    end
+
+    private
+      def load_envs
+        if destination = options[:destination]
+          Dotenv.load(".env.#{destination}", ".env")
+        else
+          Dotenv.load(".env")
+        end
+      end
+
+      def options_with_subcommand_class_options
+        options.merge(@_initializer.last[:class_options] || {})
+      end
+
+      def initialize_commander(options)
+        KAMAL.tap do |commander|
+          if options[:verbose]
+            ENV["VERBOSE"] = "1" # For backtraces via cli/start
+            commander.verbosity = :debug
+          end
+
+          if options[:quiet]
+            commander.verbosity = :error
+          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]
+        end
+      end
+
+      def print_runtime
+        started_at = Time.now
+        yield
+        return Time.now - started_at
+      ensure
+        runtime = Time.now - started_at
+        puts "  Finished all in #{sprintf("%.1f seconds", runtime)}"
+      end
+
+      def mutating
+        return yield if KAMAL.holding_lock?
+
+        KAMAL.config.ensure_env_available
+
+        run_hook "pre-connect"
+
+        acquire_lock
+
+        begin
+          yield
+        rescue
+          if KAMAL.hold_lock_on_error?
+            error "  \e[31mDeploy lock was not released\e[0m"
+          else
+            release_lock
+          end
+
+          raise
+        end
+
+        release_lock
+      end
+
+      def acquire_lock
+        raise_if_locked do
+          say "Acquiring the deploy lock...", :magenta
+          on(KAMAL.primary_host) { execute *KAMAL.lock.acquire("Automatic deploy lock", KAMAL.config.version), verbosity: :debug }
+        end
+
+        KAMAL.holding_lock = true
+      end
+
+      def release_lock
+        say "Releasing the deploy lock...", :magenta
+        on(KAMAL.primary_host) { execute *KAMAL.lock.release, verbosity: :debug }
+
+        KAMAL.holding_lock = false
+      end
+
+      def raise_if_locked
+        yield
+      rescue SSHKit::Runner::ExecuteError => e
+        if e.message =~ /cannot create directory/
+          on(KAMAL.primary_host) { puts capture_with_debug(*KAMAL.lock.status) }
+          raise LockError, "Deploy lock found"
+        else
+          raise e
+        end
+      end
+
+      def hold_lock_on_error
+        if KAMAL.hold_lock_on_error?
+          yield
+        else
+          KAMAL.hold_lock_on_error = true
+          yield
+          KAMAL.hold_lock_on_error = false
+        end
+      end
+
+      def run_hook(hook, **extra_details)
+        if !options[:skip_hooks] && KAMAL.hook.hook_exists?(hook)
+          details = { hosts: KAMAL.hosts.join(","), command: command, subcommand: subcommand }
+
+          say "Running the #{hook} hook...", :magenta
+          run_locally do
+            KAMAL.with_verbosity(:debug) { execute *KAMAL.hook.run(hook, **details, **extra_details) }
+          rescue SSHKit::Command::Failed
+            raise HookError.new("Hook `#{hook}` failed")
+          end
+        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
+    end
+end

lib/kamal/cli/build.rb

@@ -0,0 +1,106 @@
+class Kamal::Cli::Build < Kamal::Cli::Base
+  class BuildError < StandardError; end
+
+  desc "deliver", "Build app and push app image to registry then pull image on servers"
+  def deliver
+    mutating do
+      push
+      pull
+    end
+  end
+
+  desc "push", "Build and push app image to registry"
+  def push
+    mutating do
+      cli = self
+
+      verify_local_dependencies
+      run_hook "pre-build"
+
+      if (uncommitted_changes = Kamal::Utils.uncommitted_changes).present?
+        say "The following paths have uncommitted changes:\n #{uncommitted_changes}", :yellow
+      end
+
+      run_locally do
+        begin
+          KAMAL.with_verbosity(:debug) do
+            execute *KAMAL.builder.push
+          end
+        rescue SSHKit::Command::Failed => e
+          if e.message =~ /(no builder)|(no such file or directory)/
+            error "Missing compatible builder, so creating a new one first"
+
+            if cli.create
+              KAMAL.with_verbosity(:debug) { execute *KAMAL.builder.push }
+            end
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+
+  desc "pull", "Pull app image from registry onto servers"
+  def pull
+    mutating do
+      on(KAMAL.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
+      end
+    end
+  end
+
+  desc "create", "Create a build setup"
+  def create
+    mutating do
+      run_locally do
+        begin
+          debug "Using builder: #{KAMAL.builder.name}"
+          execute *KAMAL.builder.create
+        rescue SSHKit::Command::Failed => e
+          if e.message =~ /stderr=(.*)/
+            error "Couldn't create remote builder: #{$1}"
+            false
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+
+  desc "remove", "Remove build setup"
+  def remove
+    mutating do
+      run_locally do
+        debug "Using builder: #{KAMAL.builder.name}"
+        execute *KAMAL.builder.remove
+      end
+    end
+  end
+
+  desc "details", "Show build setup"
+  def details
+    run_locally do
+      puts "Builder: #{KAMAL.builder.name}"
+      puts capture(*KAMAL.builder.info)
+    end
+  end
+
+  private
+    def verify_local_dependencies
+      run_locally do
+        begin
+          execute *KAMAL.builder.ensure_local_dependencies_installed
+        rescue SSHKit::Command::Failed => e
+          build_error = e.message =~ /command not found/ ?
+            "Docker is not installed locally" :
+            "Docker buildx plugin is not installed locally"
+
+          raise BuildError, build_error
+        end
+      end
+    end
+end

lib/kamal/cli/healthcheck.rb

@@ -0,0 +1,20 @@
+class Kamal::Cli::Healthcheck < Kamal::Cli::Base
+  default_command :perform
+
+  desc "perform", "Health check current app version"
+  def perform
+    on(KAMAL.primary_host) do
+      begin
+        execute *KAMAL.healthcheck.run
+        Kamal::Utils::HealthcheckPoller.wait_for_healthy { capture_with_info(*KAMAL.healthcheck.status) }
+      rescue Kamal::Utils::HealthcheckPoller::HealthcheckError => e
+        error capture_with_info(*KAMAL.healthcheck.logs)
+        error capture_with_pretty_json(*KAMAL.healthcheck.container_health_log)
+        raise
+      ensure
+        execute *KAMAL.healthcheck.stop, raise_on_non_zero_exit: false
+        execute *KAMAL.healthcheck.remove, raise_on_non_zero_exit: false
+      end
+    end
+  end
+end

lib/kamal/cli/lock.rb

@@ -0,0 +1,37 @@
+class Kamal::Cli::Lock < Kamal::Cli::Base
+  desc "status", "Report lock status"
+  def status
+    handle_missing_lock do
+      on(KAMAL.primary_host) { puts capture_with_debug(*KAMAL.lock.status) }
+    end
+  end
+
+  desc "acquire", "Acquire the deploy lock"
+  option :message, aliases: "-m", type: :string, desc: "A lock message", required: true
+  def acquire
+    message = options[:message]
+    raise_if_locked do
+      on(KAMAL.primary_host) { execute *KAMAL.lock.acquire(message, KAMAL.config.version), verbosity: :debug }
+      say "Acquired the deploy lock"
+    end
+  end
+
+  desc "release", "Release the deploy lock"
+  def release
+    handle_missing_lock do
+      on(KAMAL.primary_host) { execute *KAMAL.lock.release, verbosity: :debug }
+      say "Released the deploy lock"
+    end
+  end
+
+  private
+    def handle_missing_lock
+      yield
+    rescue SSHKit::Runner::ExecuteError => e
+      if e.message =~ /No such file or directory/
+        say "There is no deploy lock"
+      else
+        raise
+      end
+    end
+end

lib/kamal/cli/main.rb

@@ -0,0 +1,249 @@
+class Kamal::Cli::Main < Kamal::Cli::Base
+  desc "setup", "Setup all accessories and deploy app to servers"
+  def setup
+    print_runtime do
+      mutating do
+        invoke "kamal:cli:server:bootstrap"
+        invoke "kamal:cli:accessory:boot", [ "all" ]
+        deploy
+      end
+    end
+  end
+
+  desc "deploy", "Deploy app to servers"
+  option :skip_push, aliases: "-P", type: :boolean, default: false, desc: "Skip image build and push"
+  def deploy
+    runtime = print_runtime do
+      mutating do
+        invoke_options = deploy_options
+
+        say "Log into image registry...", :magenta
+        invoke "kamal:cli:registry:login", [], invoke_options
+
+        if options[:skip_push]
+          say "Pull app image...", :magenta
+          invoke "kamal:cli:build:pull", [], invoke_options
+        else
+          say "Build and push app image...", :magenta
+          invoke "kamal:cli:build:deliver", [], invoke_options
+        end
+
+        run_hook "pre-deploy"
+
+        say "Ensure Traefik is running...", :magenta
+        invoke "kamal:cli:traefik:boot", [], invoke_options
+
+        say "Ensure app can pass healthcheck...", :magenta
+        invoke "kamal:cli:healthcheck:perform", [], invoke_options
+
+        say "Detect stale containers...", :magenta
+        invoke "kamal:cli:app:stale_containers", [], invoke_options
+
+        invoke "kamal:cli:app:boot", [], invoke_options
+
+        say "Prune old containers and images...", :magenta
+        invoke "kamal:cli:prune:all", [], invoke_options
+      end
+    end
+
+    run_hook "post-deploy", runtime: runtime.round
+  end
+
+  desc "redeploy", "Deploy app to servers without bootstrapping servers, starting Traefik, pruning, and registry login"
+  option :skip_push, aliases: "-P", type: :boolean, default: false, desc: "Skip image build and push"
+  def redeploy
+    runtime = print_runtime do
+      mutating do
+        invoke_options = deploy_options
+
+        if options[:skip_push]
+          say "Pull app image...", :magenta
+          invoke "kamal:cli:build:pull", [], invoke_options
+        else
+          say "Build and push app image...", :magenta
+          invoke "kamal:cli:build:deliver", [], invoke_options
+        end
+
+        run_hook "pre-deploy"
+
+        say "Ensure app can pass healthcheck...", :magenta
+        invoke "kamal:cli:healthcheck:perform", [], invoke_options
+
+        say "Detect stale containers...", :magenta
+        invoke "kamal:cli:app:stale_containers", [], invoke_options
+
+        invoke "kamal:cli:app:boot", [], invoke_options
+      end
+    end
+
+    run_hook "post-deploy", runtime: runtime.round
+  end
+
+  desc "rollback [VERSION]", "Rollback app to VERSION"
+  def rollback(version)
+    rolled_back = false
+    runtime = print_runtime do
+      mutating do
+        invoke_options = deploy_options
+
+        KAMAL.config.version = version
+        old_version = nil
+
+        if container_available?(version)
+          run_hook "pre-deploy"
+
+          invoke "kamal:cli:app:boot", [], invoke_options.merge(version: version)
+          rolled_back = true
+        else
+          say "The app version '#{version}' is not available as a container (use 'kamal app containers' for available versions)", :red
+        end
+      end
+    end
+
+    run_hook "post-deploy", runtime: runtime.round if rolled_back
+  end
+
+  desc "details", "Show details about all containers"
+  def details
+    invoke "kamal:cli:traefik:details"
+    invoke "kamal:cli:app:details"
+    invoke "kamal:cli:accessory:details", [ "all" ]
+  end
+
+  desc "audit", "Show audit log from servers"
+  def audit
+    on(KAMAL.hosts) do |host|
+      puts_by_host host, capture_with_info(*KAMAL.auditor.reveal)
+    end
+  end
+
+  desc "config", "Show combined config (including secrets!)"
+  def config
+    run_locally do
+      puts Kamal::Utils.redacted(KAMAL.config.to_h).to_yaml
+    end
+  end
+
+  desc "init", "Create config stub in config/deploy.yml and env stub in .env"
+  option :bundle, type: :boolean, default: false, desc: "Add Kamal to the Gemfile and create a bin/kamal binstub"
+  def init
+    require "fileutils"
+
+    if (deploy_file = Pathname.new(File.expand_path("config/deploy.yml"))).exist?
+      puts "Config file already exists in config/deploy.yml (remove first to create a new one)"
+    else
+      FileUtils.mkdir_p deploy_file.dirname
+      FileUtils.cp_r Pathname.new(File.expand_path("templates/deploy.yml", __dir__)), deploy_file
+      puts "Created configuration file in config/deploy.yml"
+    end
+
+    unless (deploy_file = Pathname.new(File.expand_path(".env"))).exist?
+      FileUtils.cp_r Pathname.new(File.expand_path("templates/template.env", __dir__)), deploy_file
+      puts "Created .env file"
+    end
+
+    unless (hooks_dir = Pathname.new(File.expand_path(".kamal/hooks"))).exist?
+      hooks_dir.mkpath
+      Pathname.new(File.expand_path("templates/sample_hooks", __dir__)).each_child do |sample_hook|
+        FileUtils.cp sample_hook, hooks_dir, preserve: true
+      end
+      puts "Created sample hooks in .kamal/hooks"
+    end
+
+    if options[:bundle]
+      if (binstub = Pathname.new(File.expand_path("bin/kamal"))).exist?
+        puts "Binstub already exists in bin/kamal (remove first to create a new one)"
+      else
+        puts "Adding Kamal to Gemfile and bundle..."
+        run_locally do
+          execute :bundle, :add, :kamal
+          execute :bundle, :binstubs, :kamal
+        end
+        puts "Created binstub file in bin/kamal"
+      end
+    end
+  end
+
+  desc "envify", "Create .env by evaluating .env.erb (or .env.staging.erb -> .env.staging when using -d staging)"
+  def envify
+    if destination = options[:destination]
+      env_template_path = ".env.#{destination}.erb"
+      env_path          = ".env.#{destination}"
+    else
+      env_template_path = ".env.erb"
+      env_path          = ".env"
+    end
+
+    File.write(env_path, ERB.new(File.read(env_template_path)).result, perm: 0600)
+  end
+
+  desc "remove", "Remove Traefik, app, accessories, and registry session from servers"
+  option :confirmed, aliases: "-y", type: :boolean, default: false, desc: "Proceed without confirmation question"
+  def remove
+    mutating do
+      if options[:confirmed] || ask("This will remove all containers and images. Are you sure?", limited_to: %w( y N ), default: "N") == "y"
+        invoke "kamal:cli:traefik:remove", [], options.without(:confirmed)
+        invoke "kamal:cli:app:remove", [], options.without(:confirmed)
+        invoke "kamal:cli:accessory:remove", [ "all" ], options
+        invoke "kamal:cli:registry:logout", [], options.without(:confirmed)
+      end
+    end
+  end
+
+  desc "version", "Show Kamal version"
+  def version
+    puts Kamal::VERSION
+  end
+
+  desc "accessory", "Manage accessories (db/redis/search)"
+  subcommand "accessory", Kamal::Cli::Accessory
+
+  desc "app", "Manage application"
+  subcommand "app", Kamal::Cli::App
+
+  desc "build", "Build application image"
+  subcommand "build", Kamal::Cli::Build
+
+  desc "healthcheck", "Healthcheck application"
+  subcommand "healthcheck", Kamal::Cli::Healthcheck
+
+  desc "lock", "Manage the deploy lock"
+  subcommand "lock", Kamal::Cli::Lock
+
+  desc "prune", "Prune old application images and containers"
+  subcommand "prune", Kamal::Cli::Prune
+
+  desc "registry", "Login and -out of the image registry"
+  subcommand "registry", Kamal::Cli::Registry
+
+  desc "server", "Bootstrap servers with curl and Docker"
+  subcommand "server", Kamal::Cli::Server
+
+  desc "traefik", "Manage Traefik load balancer"
+  subcommand "traefik", Kamal::Cli::Traefik
+
+  private
+    def container_available?(version)
+      begin
+        on(KAMAL.hosts) do
+          KAMAL.roles_on(host).each do |role|
+            container_id = capture_with_info(*KAMAL.app(role: role).container_id_for_version(version))
+            raise "Container not found" unless container_id.present?
+          end
+        end
+      rescue SSHKit::Runner::ExecuteError => e
+        if e.message =~ /Container not found/
+          say "Error looking for container version #{version}: #{e.message}"
+          return false
+        else
+          raise
+        end
+      end
+
+      true
+    end
+
+    def deploy_options
+      { "version" => KAMAL.config.version }.merge(options.without("skip_push"))
+    end
+end

lib/kamal/cli/prune.rb

@@ -0,0 +1,30 @@
+class Kamal::Cli::Prune < Kamal::Cli::Base
+  desc "all", "Prune unused images and stopped containers"
+  def all
+    mutating do
+      containers
+      images
+    end
+  end
+
+  desc "images", "Prune dangling images"
+  def images
+    mutating do
+      on(KAMAL.hosts) do
+        execute *KAMAL.auditor.record("Pruned images"), verbosity: :debug
+        execute *KAMAL.prune.dangling_images
+        execute *KAMAL.prune.tagged_images
+      end
+    end
+  end
+
+  desc "containers", "Prune all stopped containers, except the last 5"
+  def containers
+    mutating do
+      on(KAMAL.hosts) do
+        execute *KAMAL.auditor.record("Pruned containers"), verbosity: :debug
+        execute *KAMAL.prune.containers
+      end
+    end
+  end
+end

lib/kamal/cli/registry.rb

@@ -0,0 +1,18 @@
+class Kamal::Cli::Registry < Kamal::Cli::Base
+  desc "login", "Log in to registry locally and remotely"
+  def login
+    run_locally    { execute *KAMAL.registry.login }
+    on(KAMAL.hosts) { execute *KAMAL.registry.login }
+  # FIXME: This rescue needed?
+  rescue ArgumentError => e
+    puts e.message
+  end
+
+  desc "logout", "Log out of registry remotely"
+  def logout
+    on(KAMAL.hosts) { execute *KAMAL.registry.logout }
+  # FIXME: This rescue needed?
+  rescue ArgumentError => e
+    puts e.message
+  end
+end

lib/kamal/cli/server.rb

@@ -0,0 +1,21 @@
+class Kamal::Cli::Server < Kamal::Cli::Base
+  desc "bootstrap", "Set up Docker to run Kamal apps"
+  def bootstrap
+    missing = []
+
+    on(KAMAL.hosts | KAMAL.accessory_hosts) do |host|
+      unless execute(*KAMAL.docker.installed?, raise_on_non_zero_exit: false)
+        if execute(*KAMAL.docker.superuser?, raise_on_non_zero_exit: false)
+          info "Missing Docker on #{host}. Installing…"
+          execute *KAMAL.docker.install
+        else
+          missing << host
+        end
+      end
+    end
+
+    if missing.any?
+      raise "Docker is not installed on #{missing.join(", ")} and can't be automatically installed without having root access and the `curl` command available. Install Docker manually: https://docs.docker.com/engine/install/"
+    end
+  end
+end

lib/kamal/cli/templates/deploy.yml

@@ -0,0 +1,74 @@
+# Name of your application. Used to uniquely configure containers.
+service: my-app
+
+# Name of the container image.
+image: user/my-app
+
+# Deploy to these servers.
+servers:
+  - 192.168.0.1
+
+# Credentials for your image host.
+registry:
+  # Specify the registry server, if you're not using Docker Hub
+  # server: registry.digitalocean.com / ghcr.io / ...
+  username: my-user
+
+  # Always use an access token rather than real password when possible.
+  password:
+    - KAMAL_REGISTRY_PASSWORD
+
+# Inject ENV variables into containers (secrets come from .env).
+# env:
+#   clear:
+#     DB_HOST: 192.168.0.2
+#   secret:
+#     - RAILS_MASTER_KEY
+
+# Use a different ssh user than root
+# ssh:
+#   user: app
+
+# Configure builder setup.
+# builder:
+#   args:
+#     RUBY_VERSION: 3.2.0
+#   secrets:
+#     - GITHUB_TOKEN
+#   remote:
+#     arch: amd64
+#     host: ssh://app@192.168.0.1
+
+# Use accessory services (secrets come from .env).
+# accessories:
+#   db:
+#     image: mysql:8.0
+#     host: 192.168.0.2
+#     port: 3306
+#     env:
+#       clear:
+#         MYSQL_ROOT_HOST: '%'
+#       secret:
+#         - MYSQL_ROOT_PASSWORD
+#     files:
+#       - config/mysql/production.cnf:/etc/mysql/my.cnf
+#       - db/production.sql.erb:/docker-entrypoint-initdb.d/setup.sql
+#     directories:
+#       - data:/var/lib/mysql
+#   redis:
+#     image: redis:7.0
+#     host: 192.168.0.2
+#     port: 6379
+#     directories:
+#       - data:/data
+
+# Configure custom arguments for Traefik
+# traefik:
+#   args:
+#     accesslog: true
+#     accesslog.format: json
+
+# Configure a custom healthcheck (default is /up on port 3000)
+# healthcheck:
+#   path: /healthz
+#   port: 4000

lib/kamal/cli/templates/sample_hooks/post-deploy.sample

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+# A sample post-deploy hook
+#
+# These environment variables are available:
+# KAMAL_RECORDED_AT
+# KAMAL_PERFORMER
+# KAMAL_VERSION
+# KAMAL_HOSTS
+# KAMAL_ROLE (if set)
+# KAMAL_DESTINATION (if set)
+# KAMAL_RUNTIME
+
+echo "$KAMAL_PERFORMER deployed $KAMAL_VERSION to $KAMAL_DESTINATION in $KAMAL_RUNTIME seconds"

lib/kamal/cli/templates/sample_hooks/pre-build.sample

@@ -0,0 +1,51 @@
+#!/bin/sh
+
+# A sample pre-build hook
+#
+# Checks:
+# 1. We have a clean checkout
+# 2. A remote is configured
+# 3. The branch has been pushed to the remote
+# 4. The version we are deploying matches the remote
+#
+# These environment variables are available:
+# KAMAL_RECORDED_AT
+# KAMAL_PERFORMER
+# KAMAL_VERSION
+# KAMAL_HOSTS
+# KAMAL_ROLE (if set)
+# KAMAL_DESTINATION (if set)
+
+if [ -n "$(git status --porcelain)" ]; then
+  echo "Git checkout is not clean, aborting..." >&2
+  git status --porcelain >&2
+  exit 1
+fi
+
+first_remote=$(git remote)
+
+if [ -z "$first_remote" ]; then
+  echo "No git remote set, aborting..." >&2
+  exit 1
+fi
+
+current_branch=$(git branch --show-current)
+
+if [ -z "$current_branch" ]; then
+  echo "No git remote set, aborting..." >&2
+  exit 1
+fi
+
+remote_head=$(git ls-remote $first_remote --tags $current_branch | cut -f1)
+
+if [ -z "$remote_head" ]; then
+  echo "Branch not pushed to remote, aborting..." >&2
+  exit 1
+fi
+
+if [ "$KAMAL_VERSION" != "$remote_head" ]; then
+  echo "Version ($KAMAL_VERSION) does not match remote HEAD ($remote_head), aborting..." >&2
+  exit 1
+fi
+
+exit 0

lib/kamal/cli/templates/sample_hooks/pre-connect.sample

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+# A sample pre-connect check
+#
+# Warms DNS before connecting to hosts in parallel
+#
+# These environment variables are available:
+# KAMAL_RECORDED_AT
+# KAMAL_PERFORMER
+# KAMAL_VERSION
+# KAMAL_HOSTS
+# KAMAL_ROLE (if set)
+# KAMAL_DESTINATION (if set)
+# KAMAL_RUNTIME
+
+hosts = ENV["KAMAL_HOSTS"].split(",")
+results = nil
+max = 3
+
+elapsed = Benchmark.realtime do
+  results = hosts.map do |host|
+    Thread.new do
+      tries = 1
+
+      begin
+        Socket.getaddrinfo(host, 0, Socket::AF_UNSPEC, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME)
+      rescue SocketError
+        if tries < max
+          puts "Retrying DNS warmup: #{host}"
+          tries += 1
+          sleep rand
+          retry
+        else
+          puts "DNS warmup failed: #{host}"
+          host
+        end
+      end
+
+      tries
+    end
+  end.map(&:value)
+end
+
+retries = results.sum - hosts.size
+nopes = results.count { |r| r == max }
+
+puts "Prewarmed %d DNS lookups in %.2f sec: %d retries, %d failures" % [ hosts.size, elapsed, retries, nopes ]

lib/kamal/cli/templates/sample_hooks/pre-deploy.sample

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+
+# A sample pre-deploy hook
+#
+# Checks the Github status of the build, waiting for a pending build to complete for up to 720 seconds.
+#
+# Fails unless the combined status is "success"
+#
+# These environment variables are available:
+# KAMAL_RECORDED_AT
+# KAMAL_PERFORMER
+# KAMAL_VERSION
+# KAMAL_HOSTS
+# KAMAL_COMMAND
+# KAMAL_SUBCOMMAND
+# KAMAL_ROLE (if set)
+# KAMAL_DESTINATION (if set)
+
+# Only check the build status for production deployments
+if ENV["KAMAL_COMMAND"] == "rollback" || ENV["KAMAL_DESTINATION"] != "production"
+  exit 0
+end
+
+require "bundler/inline"
+
+# true = install gems so this is fast on repeat invocations
+gemfile(true, quiet: true) do
+  source "https://rubygems.org"
+
+  gem "octokit"
+  gem "faraday-retry"
+end
+
+MAX_ATTEMPTS = 72
+ATTEMPTS_GAP = 10
+
+def exit_with_error(message)
+  $stderr.puts message
+  exit 1
+end
+
+class GithubStatusChecks
+  attr_reader :remote_url, :git_sha, :github_client, :combined_status
+
+  def initialize
+    @remote_url = `git config --get remote.origin.url`.strip.delete_prefix("https://github.com/")
+    @git_sha = `git rev-parse HEAD`.strip
+    @github_client = Octokit::Client.new(access_token: ENV["GITHUB_TOKEN"])
+    refresh!
+  end
+
+  def refresh!
+    @combined_status = github_client.combined_status(remote_url, git_sha)
+  end
+
+  def state
+    combined_status[:state]
+  end
+
+  def first_status_url
+    first_status = combined_status[:statuses].find { |status| status[:state] == state }
+    first_status && first_status[:target_url]
+  end
+
+  def complete_count
+    combined_status[:statuses].count { |status| status[:state] != "pending"}
+  end
+
+  def total_count
+    combined_status[:statuses].count
+  end
+
+  def current_status
+    if total_count > 0
+      "Completed #{complete_count}/#{total_count} checks, see #{first_status_url} ..."
+    else
+      "Build not started..."
+    end
+  end
+end
+
+
+$stdout.sync = true
+
+puts "Checking build status..."
+attempts = 0
+checks = GithubStatusChecks.new
+
+begin
+  loop do
+    case checks.state
+    when "success"
+      puts "Checks passed, see #{checks.first_status_url}"
+      exit 0
+    when "failure"
+      exit_with_error "Checks failed, see #{checks.first_status_url}"
+    when "pending"
+      attempts += 1
+    end
+
+    exit_with_error "Checks are still pending, gave up after #{MAX_ATTEMPTS * ATTEMPTS_GAP} seconds" if attempts == MAX_ATTEMPTS
+
+    puts checks.current_status
+    sleep(ATTEMPTS_GAP)
+    checks.refresh!
+  end
+rescue Octokit::NotFound
+  exit_with_error "Build status could not be found"
+end

lib/kamal/cli/templates/template.env

@@ -0,0 +1,2 @@
+KAMAL_REGISTRY_PASSWORD=change-this
+RAILS_MASTER_KEY=another-env

lib/kamal/cli/traefik.rb

@@ -0,0 +1,111 @@
+class Kamal::Cli::Traefik < Kamal::Cli::Base
+  desc "boot", "Boot Traefik on servers"
+  def boot
+    mutating do
+      on(KAMAL.traefik_hosts) do
+        execute *KAMAL.registry.login
+        execute *KAMAL.traefik.start_or_run
+      end
+    end
+  end
+
+  desc "reboot", "Reboot Traefik on servers (stop container, remove container, start new container)"
+  option :rolling, type: :boolean, default: false, desc: "Reboot traefik on hosts in sequence, rather than in parallel"
+  def reboot
+    mutating do
+      on(KAMAL.traefik_hosts, in: options[:rolling] ? :sequence : :parallel) do
+        execute *KAMAL.auditor.record("Rebooted traefik"), verbosity: :debug
+        execute *KAMAL.registry.login
+        execute *KAMAL.traefik.stop
+        execute *KAMAL.traefik.remove_container
+        execute *KAMAL.traefik.run
+      end
+    end
+  end
+
+  desc "start", "Start existing Traefik container on servers"
+  def start
+    mutating do
+      on(KAMAL.traefik_hosts) do
+        execute *KAMAL.auditor.record("Started traefik"), verbosity: :debug
+        execute *KAMAL.traefik.start
+      end
+    end
+  end
+
+  desc "stop", "Stop existing Traefik container on servers"
+  def stop
+    mutating do
+      on(KAMAL.traefik_hosts) do
+        execute *KAMAL.auditor.record("Stopped traefik"), verbosity: :debug
+        execute *KAMAL.traefik.stop
+      end
+    end
+  end
+
+  desc "restart", "Restart existing Traefik container on servers"
+  def restart
+    mutating do
+      stop
+      start
+    end
+  end
+
+  desc "details", "Show details about Traefik container from servers"
+  def details
+    on(KAMAL.traefik_hosts) { |host| puts_by_host host, capture_with_info(*KAMAL.traefik.info), type: "Traefik" }
+  end
+
+  desc "logs", "Show log lines from Traefik on servers"
+  option :since, aliases: "-s", desc: "Show logs 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 log lines to pull from each server"
+  option :grep, aliases: "-g", desc: "Show lines with grep match only (use this to fetch specific requests by id)"
+  option :follow, aliases: "-f", desc: "Follow logs on primary server (or specific host set by --hosts)"
+  def logs
+    grep = options[:grep]
+
+    if options[:follow]
+      run_locally do
+        info "Following logs on #{KAMAL.primary_host}..."
+        info KAMAL.traefik.follow_logs(host: KAMAL.primary_host, grep: grep)
+        exec KAMAL.traefik.follow_logs(host: KAMAL.primary_host, grep: grep)
+      end
+    else
+      since = options[:since]
+      lines = options[:lines].presence || ((since || grep) ? nil : 100) # Default to 100 lines if since or grep isn't set
+
+      on(KAMAL.traefik_hosts) do |host|
+        puts_by_host host, capture(*KAMAL.traefik.logs(since: since, lines: lines, grep: grep)), type: "Traefik"
+      end
+    end
+  end
+
+  desc "remove", "Remove Traefik container and image from servers"
+  def remove
+    mutating do
+      stop
+      remove_container
+      remove_image
+    end
+  end
+
+  desc "remove_container", "Remove Traefik container from servers", hide: true
+  def remove_container
+    mutating do
+      on(KAMAL.traefik_hosts) do
+        execute *KAMAL.auditor.record("Removed traefik container"), verbosity: :debug
+        execute *KAMAL.traefik.remove_container
+      end
+    end
+  end
+
+  desc "remove_image", "Remove Traefik image from servers", hide: true
+  def remove_image
+    mutating do
+      on(KAMAL.traefik_hosts) do
+        execute *KAMAL.auditor.record("Removed traefik image"), verbosity: :debug
+        execute *KAMAL.traefik.remove_image
+      end
+    end
+  end
+end

lib/kamal/commander.rb

@@ -0,0 +1,154 @@
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/module/delegation"
+
+class Kamal::Commander
+  attr_accessor :verbosity, :holding_lock, :hold_lock_on_error
+
+  def initialize
+    self.verbosity = :info
+    self.holding_lock = false
+    self.hold_lock_on_error = false
+  end
+
+  def config
+    @config ||= Kamal::Configuration.create_from(**@config_kwargs).tap do |config|
+      @config_kwargs = nil
+      configure_sshkit_with(config)
+    end
+  end
+
+  def configure(**kwargs)
+    @config, @config_kwargs = nil, kwargs
+  end
+
+  attr_reader :specific_roles, :specific_hosts
+
+  def specific_primary!
+    self.specific_hosts = [ config.primary_web_host ]
+  end
+
+  def specific_roles=(role_names)
+    @specific_roles = config.roles.select { |r| role_names.include?(r.name) } if role_names.present?
+  end
+
+  def specific_hosts=(hosts)
+    @specific_hosts = config.all_hosts & hosts if hosts.present?
+  end
+
+  def primary_host
+    specific_hosts&.first || specific_roles&.first&.primary_host || config.primary_web_host
+  end
+
+  def roles
+    (specific_roles || config.roles).select do |role|
+      ((specific_hosts || config.all_hosts) & role.hosts).any?
+    end
+  end
+
+  def hosts
+    (specific_hosts || config.all_hosts).select do |host|
+      (specific_roles || config.roles).flat_map(&:hosts).include?(host)
+    end
+  end
+
+  def boot_strategy
+    if config.boot.limit.present?
+      { in: :groups, limit: config.boot.limit, wait: config.boot.wait }
+    else
+      {}
+    end
+  end
+
+  def roles_on(host)
+    roles.select { |role| role.hosts.include?(host.to_s) }.map(&:name)
+  end
+
+  def traefik_hosts
+    specific_hosts || config.traefik_hosts
+  end
+
+  def accessory_hosts
+    specific_hosts || config.accessories.flat_map(&:hosts)
+  end
+
+  def accessory_names
+    config.accessories&.collect(&:name) || []
+  end
+
+
+  def app(role: nil)
+    Kamal::Commands::App.new(config, role: role)
+  end
+
+  def accessory(name)
+    Kamal::Commands::Accessory.new(config, name: name)
+  end
+
+  def auditor(**details)
+    Kamal::Commands::Auditor.new(config, **details)
+  end
+
+  def builder
+    @builder ||= Kamal::Commands::Builder.new(config)
+  end
+
+  def docker
+    @docker ||= Kamal::Commands::Docker.new(config)
+  end
+
+  def healthcheck
+    @healthcheck ||= Kamal::Commands::Healthcheck.new(config)
+  end
+
+  def hook
+    @hook ||= Kamal::Commands::Hook.new(config)
+  end
+
+  def lock
+    @lock ||= Kamal::Commands::Lock.new(config)
+  end
+
+  def prune
+    @prune ||= Kamal::Commands::Prune.new(config)
+  end
+
+  def registry
+    @registry ||= Kamal::Commands::Registry.new(config)
+  end
+
+  def traefik
+    @traefik ||= Kamal::Commands::Traefik.new(config)
+  end
+
+  def with_verbosity(level)
+    old_level = self.verbosity
+
+    self.verbosity = level
+    SSHKit.config.output_verbosity = level
+
+    yield
+  ensure
+    self.verbosity = old_level
+    SSHKit.config.output_verbosity = old_level
+  end
+
+  def holding_lock?
+    self.holding_lock
+  end
+
+  def hold_lock_on_error?
+    self.hold_lock_on_error
+  end
+
+  private
+    # Lazy setup of SSHKit
+    def configure_sshkit_with(config)
+      SSHKit::Backend::Netssh.pool.idle_timeout = config.sshkit.pool_idle_timeout
+      SSHKit::Backend::Netssh.configure do |sshkit|
+        sshkit.max_concurrent_starts = config.sshkit.max_concurrent_starts
+        sshkit.ssh_options = config.ssh.options
+      end
+      SSHKit.config.command_map[:docker] = "docker" # No need to use /usr/bin/env, just clogs up the logs
+      SSHKit.config.output_verbosity = verbosity
+    end
+end

lib/kamal/commands.rb

@@ -0,0 +1,2 @@
+module Kamal::Commands
+end

lib/kamal/commands/accessory.rb

@@ -0,0 +1,113 @@
+class Kamal::Commands::Accessory < Kamal::Commands::Base
+  attr_reader :accessory_config
+  delegate :service_name, :image, :hosts, :port, :files, :directories, :cmd,
+           :publish_args, :env_args, :volume_args, :label_args, :option_args, to: :accessory_config
+
+  def initialize(config, name:)
+    super(config)
+    @accessory_config = config.accessory(name)
+  end
+
+  def run
+    docker :run,
+      "--name", service_name,
+      "--detach",
+      "--restart", "unless-stopped",
+      *config.logging_args,
+      *publish_args,
+      *env_args,
+      *volume_args,
+      *label_args,
+      *option_args,
+      image,
+      cmd
+  end
+
+  def start
+    docker :container, :start, service_name
+  end
+
+  def stop
+    docker :container, :stop, service_name
+  end
+
+  def info
+    docker :ps, *service_filter
+  end
+
+
+  def logs(since: nil, lines: nil, grep: nil)
+    pipe \
+      docker(:logs, service_name, (" --since #{since}" if since), (" --tail #{lines}" if lines), "--timestamps", "2>&1"),
+      ("grep '#{grep}'" if grep)
+  end
+
+  def follow_logs(grep: nil)
+    run_over_ssh \
+      pipe \
+        docker(:logs, service_name, "--timestamps", "--tail", "10", "--follow", "2>&1"),
+        (%(grep "#{grep}") if grep)
+  end
+
+
+  def execute_in_existing_container(*command, interactive: false)
+    docker :exec,
+      ("-it" if interactive),
+      service_name,
+      *command
+  end
+
+  def execute_in_new_container(*command, interactive: false)
+    docker :run,
+      ("-it" if interactive),
+      "--rm",
+      *env_args,
+      *volume_args,
+      image,
+      *command
+  end
+
+  def execute_in_existing_container_over_ssh(*command)
+    run_over_ssh execute_in_existing_container(*command, interactive: true)
+  end
+
+  def execute_in_new_container_over_ssh(*command)
+    run_over_ssh execute_in_new_container(*command, interactive: true)
+  end
+
+  def run_over_ssh(command)
+    super command, host: hosts.first
+  end
+
+
+  def ensure_local_file_present(local_file)
+    if !local_file.is_a?(StringIO) && !Pathname.new(local_file).exist?
+      raise "Missing file: #{local_file}"
+    end
+  end
+
+  def make_directory_for(remote_file)
+    make_directory Pathname.new(remote_file).dirname.to_s
+  end
+
+  def make_directory(path)
+    [ :mkdir, "-p", path ]
+  end
+
+  def remove_service_directory
+    [ :rm, "-rf", service_name ]
+  end
+
+  def remove_container
+    docker :container, :prune, "--force", *service_filter
+  end
+
+  def remove_image
+    docker :image, :rm, "--force", image
+  end
+
+  private
+    def service_filter
+      [ "--filter", "label=service=#{service_name}" ]
+    end
+end

lib/kamal/commands/app.rb

@@ -0,0 +1,175 @@
+class Kamal::Commands::App < Kamal::Commands::Base
+  ACTIVE_DOCKER_STATUSES = [ :running, :restarting ]
+
+  attr_reader :role
+
+  def initialize(config, role: nil)
+    super(config)
+    @role = role
+  end
+
+  def start_or_run(hostname: nil)
+    combine start, run(hostname: hostname), by: "||"
+  end
+
+  def run(hostname: nil)
+    role = config.role(self.role)
+
+    docker :run,
+      "--detach",
+      "--restart unless-stopped",
+      "--name", container_name,
+      *(["--hostname", hostname] if hostname),
+      "-e", "KAMAL_CONTAINER_NAME=\"#{container_name}\"",
+      *role.env_args,
+      *role.health_check_args,
+      *config.logging_args,
+      *config.volume_args,
+      *role.label_args,
+      *role.option_args,
+      config.absolute_image,
+      role.cmd
+  end
+
+  def start
+    docker :start, container_name
+  end
+
+  def status(version:)
+    pipe container_id_for_version(version), xargs(docker(:inspect, "--format", DOCKER_HEALTH_STATUS_FORMAT))
+  end
+
+  def stop(version: nil)
+    pipe \
+      version ? container_id_for_version(version) : current_running_container_id,
+      xargs(config.stop_wait_time ? docker(:stop, "-t", config.stop_wait_time) : docker(:stop))
+  end
+
+  def info
+    docker :ps, *filter_args
+  end
+
+
+  def logs(since: nil, lines: nil, grep: nil)
+    pipe \
+      current_running_container_id,
+      "xargs docker logs#{" --since #{since}" if since}#{" --tail #{lines}" if lines} 2>&1",
+      ("grep '#{grep}'" if grep)
+  end
+
+  def follow_logs(host:, grep: nil)
+    run_over_ssh \
+      pipe(
+        current_running_container_id,
+        "xargs docker logs --timestamps --tail 10 --follow 2>&1",
+        (%(grep "#{grep}") if grep)
+      ),
+      host: host
+  end
+
+
+  def execute_in_existing_container(*command, interactive: false)
+    docker :exec,
+      ("-it" if interactive),
+      container_name,
+      *command
+  end
+
+  def execute_in_new_container(*command, interactive: false)
+    role = config.role(self.role)
+
+    docker :run,
+      ("-it" if interactive),
+      "--rm",
+      *config.env_args,
+      *config.volume_args,
+      *role&.option_args,
+      config.absolute_image,
+      *command
+  end
+
+  def execute_in_existing_container_over_ssh(*command, host:)
+    run_over_ssh execute_in_existing_container(*command, interactive: true), host: host
+  end
+
+  def execute_in_new_container_over_ssh(*command, host:)
+    run_over_ssh execute_in_new_container(*command, interactive: true), host: host
+  end
+
+
+  def current_running_container_id
+    docker :ps, "--quiet", *filter_args(statuses: ACTIVE_DOCKER_STATUSES), "--latest"
+  end
+
+  def container_id_for_version(version, only_running: false)
+    container_id_for(container_name: container_name(version), only_running: only_running)
+  end
+
+  def current_running_version
+    list_versions("--latest", statuses: ACTIVE_DOCKER_STATUSES)
+  end
+
+  def list_versions(*docker_args, statuses: nil)
+    pipe \
+      docker(:ps, *filter_args(statuses: statuses), *docker_args, "--format", '"{{.Names}}"'),
+      %(while read line; do echo ${line##{service_role_dest}-}; done) # Extract SHA from "service-role-dest-SHA"
+  end
+
+  def list_containers
+    docker :container, :ls, "--all", *filter_args
+  end
+
+  def list_container_names
+    [ *list_containers, "--format", "'{{ .Names }}'" ]
+  end
+
+  def remove_container(version:)
+    pipe \
+      container_id_for(container_name: container_name(version)),
+      xargs(docker(:container, :rm))
+  end
+
+  def rename_container(version:, new_version:)
+    docker :rename, container_name(version), container_name(new_version)
+  end
+
+  def remove_containers
+    docker :container, :prune, "--force", *filter_args
+  end
+
+  def list_images
+    docker :image, :ls, config.repository
+  end
+
+  def remove_images
+    docker :image, :prune, "--all", "--force", *filter_args
+  end
+
+  def tag_current_as_latest
+    docker :tag, config.absolute_image, config.latest_image
+  end
+
+
+  private
+    def container_name(version = nil)
+      [ config.service, role, config.destination, version || config.version ].compact.join("-")
+    end
+
+    def filter_args(statuses: nil)
+      argumentize "--filter", filters(statuses: statuses)
+    end
+
+    def service_role_dest
+      [config.service, role, config.destination].compact.join("-")
+    end
+
+    def filters(statuses: nil)
+      [ "label=service=#{config.service}" ].tap do |filters|
+        filters << "label=destination=#{config.destination}" if config.destination
+        filters << "label=role=#{role}" if role
+        statuses&.each do |status|
+          filters << "status=#{status}"
+        end
+      end
+    end
+end

lib/kamal/commands/auditor.rb

@@ -0,0 +1,28 @@
+class Kamal::Commands::Auditor < Kamal::Commands::Base
+  attr_reader :details
+
+  def initialize(config, **details)
+    super(config)
+    @details = details
+  end
+
+  # Runs remotely
+  def record(line, **details)
+    append \
+      [ :echo, audit_tags(**details).except(:version, :service_version).to_s, line ],
+      audit_log_file
+  end
+
+  def reveal
+    [ :tail, "-n", 50, audit_log_file ]
+  end
+
+  private
+    def audit_log_file
+      [ "kamal", config.service, config.destination, "audit.log" ].compact.join("-")
+    end
+
+    def audit_tags(**details)
+      tags(**self.details, **details)
+    end
+end

lib/kamal/commands/base.rb

@@ -0,0 +1,65 @@
+module Kamal::Commands
+  class Base
+    delegate :sensitive, :argumentize, to: Kamal::Utils
+
+    DOCKER_HEALTH_STATUS_FORMAT = "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'"
+    DOCKER_HEALTH_LOG_FORMAT    = "'{{json .State.Health}}'"
+
+    attr_accessor :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def run_over_ssh(*command, host:)
+      "ssh".tap do |cmd|
+        if config.ssh.proxy && config.ssh.proxy.is_a?(Net::SSH::Proxy::Jump)
+          cmd << " -J #{config.ssh.proxy.jump_proxies}"
+        elsif config.ssh.proxy && config.ssh.proxy.is_a?(Net::SSH::Proxy::Command)
+          cmd << " -o ProxyCommand='#{config.ssh.proxy.command_line_template}'"
+        end
+        cmd << " -t #{config.ssh.user}@#{host} '#{command.join(" ")}'"
+      end
+    end
+
+    def container_id_for(container_name:, only_running: false)
+      docker :container, :ls, *("--all" unless only_running), "--filter", "name=^#{container_name}$", "--quiet"
+    end
+
+    private
+      def combine(*commands, by: "&&")
+        commands
+          .compact
+          .collect { |command| Array(command) + [ by ] }.flatten # Join commands
+          .tap     { |commands| commands.pop } # Remove trailing combiner
+      end
+
+      def chain(*commands)
+        combine *commands, by: ";"
+      end
+
+      def pipe(*commands)
+        combine *commands, by: "|"
+      end
+
+      def append(*commands)
+        combine *commands, by: ">>"
+      end
+
+      def write(*commands)
+        combine *commands, by: ">"
+      end
+
+      def xargs(command)
+        [ :xargs, command ].flatten
+      end
+
+      def docker(*args)
+        args.compact.unshift :docker
+      end
+
+      def tags(**details)
+        Kamal::Tags.from_config(config, **details)
+      end
+  end
+end

lib/kamal/commands/builder.rb

@@ -0,0 +1,62 @@
+class Kamal::Commands::Builder < Kamal::Commands::Base
+  delegate :create, :remove, :push, :clean, :pull, :info, to: :target
+
+  def name
+    target.class.to_s.remove("Kamal::Commands::Builder::").underscore.inquiry
+  end
+
+  def target
+    case
+    when !config.builder.multiarch? && !config.builder.cached?
+      native
+    when !config.builder.multiarch? && config.builder.cached?
+      native_cached
+    when config.builder.local? && config.builder.remote?
+      multiarch_remote
+    when config.builder.remote?
+      native_remote
+    else
+      multiarch
+    end
+  end
+
+  def native
+    @native ||= Kamal::Commands::Builder::Native.new(config)
+  end
+
+  def native_cached
+    @native ||= Kamal::Commands::Builder::Native::Cached.new(config)
+  end
+
+  def native_remote
+    @native ||= Kamal::Commands::Builder::Native::Remote.new(config)
+  end
+
+  def multiarch
+    @multiarch ||= Kamal::Commands::Builder::Multiarch.new(config)
+  end
+
+  def multiarch_remote
+    @multiarch_remote ||= Kamal::Commands::Builder::Multiarch::Remote.new(config)
+  end
+
+
+  def ensure_local_dependencies_installed
+    if name.native?
+      ensure_local_docker_installed
+    else
+      combine \
+        ensure_local_docker_installed,
+        ensure_local_buildx_installed
+    end
+  end
+
+  private
+    def ensure_local_docker_installed
+      docker "--version"
+    end
+
+    def ensure_local_buildx_installed
+      docker :buildx, "version"
+    end
+end

lib/kamal/commands/builder/base.rb

@@ -0,0 +1,60 @@
+
+class Kamal::Commands::Builder::Base < Kamal::Commands::Base
+  class BuilderError < StandardError; end
+
+  delegate :argumentize, to: Kamal::Utils
+  delegate :args, :secrets, :dockerfile, :local_arch, :local_host, :remote_arch, :remote_host, :cache_from, :cache_to, to: :builder_config
+
+  def clean
+    docker :image, :rm, "--force", config.absolute_image
+  end
+
+  def pull
+    docker :pull, config.absolute_image
+  end
+
+  def build_options
+    [ *build_tags, *build_cache, *build_labels, *build_args, *build_secrets, *build_dockerfile ]
+  end
+
+  def build_context
+    config.builder.context
+  end
+
+
+  private
+    def build_tags
+      [ "-t", config.absolute_image, "-t", config.latest_image ]
+    end
+
+    def build_cache
+      if cache_to && cache_from
+        ["--cache-to", cache_to,
+          "--cache-from", cache_from]
+      end
+    end
+
+    def build_labels
+      argumentize "--label", { service: config.service }
+    end
+
+    def build_args
+      argumentize "--build-arg", args, sensitive: true
+    end
+
+    def build_secrets
+      argumentize "--secret", secrets.collect { |secret| [ "id", secret ] }
+    end
+
+    def build_dockerfile
+      if Pathname.new(File.expand_path(dockerfile)).exist?
+        argumentize "--file", dockerfile
+      else
+        raise BuilderError, "Missing #{dockerfile}"
+      end
+    end
+
+    def builder_config
+      config.builder
+    end
+end

lib/kamal/commands/builder/multiarch.rb

@@ -0,0 +1,29 @@
+class Kamal::Commands::Builder::Multiarch < Kamal::Commands::Builder::Base
+  def create
+    docker :buildx, :create, "--use", "--name", builder_name
+  end
+
+  def remove
+    docker :buildx, :rm, builder_name
+  end
+
+  def push
+    docker :buildx, :build,
+      "--push",
+      "--platform", "linux/amd64,linux/arm64",
+      "--builder", builder_name,
+      *build_options,
+      build_context
+  end
+
+  def info
+    combine \
+      docker(:context, :ls),
+      docker(:buildx, :ls)
+  end
+
+  private
+    def builder_name
+      "kamal-#{config.service}-multiarch"
+    end
+end

lib/kamal/commands/builder/multiarch/remote.rb

@@ -0,0 +1,51 @@
+class Kamal::Commands::Builder::Multiarch::Remote < Kamal::Commands::Builder::Multiarch
+  def create
+    combine \
+      create_contexts,
+      create_local_buildx,
+      append_remote_buildx
+  end
+
+  def remove
+    combine \
+      remove_contexts,
+      super
+  end
+
+  private
+    def builder_name
+      super + "-remote"
+    end
+
+    def builder_name_with_arch(arch)
+      "#{builder_name}-#{arch}"
+    end
+
+    def create_local_buildx
+      docker :buildx, :create, "--name", builder_name, builder_name_with_arch(local_arch), "--platform", "linux/#{local_arch}"
+    end
+
+    def append_remote_buildx
+      docker :buildx, :create, "--append", "--name", builder_name, builder_name_with_arch(remote_arch), "--platform", "linux/#{remote_arch}"
+    end
+
+    def create_contexts
+      combine \
+        create_context(local_arch, local_host),
+        create_context(remote_arch, remote_host)
+    end
+
+    def create_context(arch, host)
+      docker :context, :create, builder_name_with_arch(arch), "--description", "'#{builder_name} #{arch} native host'", "--docker", "'host=#{host}'"
+    end
+
+    def remove_contexts
+      combine \
+        remove_context(local_arch),
+        remove_context(remote_arch)
+    end
+
+    def remove_context(arch)
+      docker :context, :rm, builder_name_with_arch(arch)
+    end
+end

lib/kamal/commands/builder/native.rb

@@ -0,0 +1,20 @@
+class Kamal::Commands::Builder::Native < Kamal::Commands::Builder::Base
+  def create
+    # No-op on native without cache
+  end
+
+  def remove
+    # No-op on native without cache
+  end
+
+  def push
+    combine \
+      docker(:build, *build_options, build_context),
+      docker(:push, config.absolute_image),
+      docker(:push, config.latest_image)
+  end
+
+  def info
+    # No-op on native
+  end
+end

lib/kamal/commands/builder/native/cached.rb

@@ -0,0 +1,16 @@
+class Kamal::Commands::Builder::Native::Cached < Kamal::Commands::Builder::Native
+  def create
+    docker :buildx, :create, "--use", "--driver=docker-container"
+  end
+
+  def remove
+    docker :buildx, :rm, builder_name
+  end
+
+  def push
+    docker :buildx, :build,
+      "--push",
+      *build_options,
+      build_context
+  end
+end

lib/kamal/commands/builder/native/remote.rb

@@ -0,0 +1,59 @@
+class Kamal::Commands::Builder::Native::Remote < Kamal::Commands::Builder::Native
+  def create
+    chain \
+      create_context,
+      create_buildx
+  end
+
+  def remove
+    chain \
+      remove_context,
+      remove_buildx
+  end
+
+  def push
+    docker :buildx, :build,
+      "--push",
+      "--platform", platform,
+      "--builder", builder_name,
+      *build_options,
+      build_context
+  end
+
+  def info
+    chain \
+      docker(:context, :ls),
+      docker(:buildx, :ls)
+  end
+
+
+  private
+    def builder_name
+      "kamal-#{config.service}-native-remote"
+    end
+
+    def builder_name_with_arch
+      "#{builder_name}-#{remote_arch}"
+    end
+
+    def platform
+      "linux/#{remote_arch}"
+    end
+
+    def create_context
+      docker :context, :create,
+        builder_name_with_arch, "--description", "'#{builder_name} #{remote_arch} native host'", "--docker", "'host=#{remote_host}'"
+    end
+
+    def remove_context
+      docker :context, :rm, builder_name_with_arch
+    end
+
+    def create_buildx
+      docker :buildx, :create, "--name", builder_name, builder_name_with_arch, "--platform", platform
+    end
+
+    def remove_buildx
+      docker :buildx, :rm, builder_name
+    end
+end

lib/kamal/commands/docker.rb

@@ -0,0 +1,21 @@
+class Kamal::Commands::Docker < Kamal::Commands::Base
+  # Install Docker using the https://github.com/docker/docker-install convenience script.
+  def install
+    pipe [ :curl, "-fsSL", "https://get.docker.com" ], :sh
+  end
+
+  # Checks the Docker client version. Fails if Docker is not installed.
+  def installed?
+    docker "-v"
+  end
+
+  # Checks the Docker server version. Fails if Docker is not running.
+  def running?
+    docker :version
+  end
+
+  # Do we have superuser access to install Docker and start system services?
+  def superuser?
+    [ '[ "${EUID:-$(id -u)}" -eq 0 ]' ]
+  end
+end

lib/kamal/commands/healthcheck.rb

@@ -0,0 +1,57 @@
+class Kamal::Commands::Healthcheck < Kamal::Commands::Base
+  EXPOSED_PORT = 3999
+
+  def run
+    web = config.role(:web)
+
+    docker :run,
+      "--detach",
+      "--name", container_name_with_version,
+      "--publish", "#{EXPOSED_PORT}:#{config.healthcheck["port"]}",
+      "--label", "service=#{container_name}",
+      "-e", "KAMAL_CONTAINER_NAME=\"#{container_name}\"",
+      *web.env_args,
+      *web.health_check_args,
+      *config.volume_args,
+      *web.option_args,
+      config.absolute_image,
+      web.cmd
+  end
+
+  def status
+    pipe container_id, xargs(docker(:inspect, "--format", DOCKER_HEALTH_STATUS_FORMAT))
+  end
+
+  def container_health_log
+    pipe container_id, xargs(docker(:inspect, "--format", DOCKER_HEALTH_LOG_FORMAT))
+  end
+
+  def logs
+    pipe container_id, xargs(docker(:logs, "--tail", 50, "2>&1"))
+  end
+
+  def stop
+    pipe container_id, xargs(docker(:stop))
+  end
+
+  def remove
+    pipe container_id, xargs(docker(:container, :rm))
+  end
+
+  private
+    def container_name
+      [ "healthcheck", config.service, config.destination ].compact.join("-")
+    end
+
+    def container_name_with_version
+      "#{container_name}-#{config.version}"
+    end
+
+    def container_id
+      container_id_for(container_name: container_name_with_version)
+    end
+
+    def health_url
+      "http://localhost:#{EXPOSED_PORT}#{config.healthcheck["path"]}"
+    end
+end

lib/kamal/commands/hook.rb

@@ -0,0 +1,14 @@
+class Kamal::Commands::Hook < Kamal::Commands::Base
+  def run(hook, **details)
+    [ hook_file(hook), env: tags(**details).env ]
+  end
+
+  def hook_exists?(hook)
+    Pathname.new(hook_file(hook)).exist?
+  end
+
+  private
+    def hook_file(hook)
+      "#{config.hooks_path}/#{hook}"
+    end
+end

lib/kamal/commands/lock.rb

@@ -0,0 +1,63 @@
+require "active_support/duration"
+require "time"
+
+class Kamal::Commands::Lock < Kamal::Commands::Base
+  def acquire(message, version)
+    combine \
+      [:mkdir, lock_dir],
+      write_lock_details(message, version)
+  end
+
+  def release
+    combine \
+      [:rm, lock_details_file],
+      [:rm, "-r", lock_dir]
+  end
+
+  def status
+    combine \
+      stat_lock_dir,
+      read_lock_details
+  end
+
+  private
+    def write_lock_details(message, version)
+      write \
+        [:echo, "\"#{Base64.encode64(lock_details(message, version))}\""],
+        lock_details_file
+    end
+
+    def read_lock_details
+      pipe \
+        [:cat, lock_details_file],
+        [:base64, "-d"]
+    end
+
+    def stat_lock_dir
+      write \
+        [:stat, lock_dir],
+        "/dev/null"
+    end
+
+    def lock_dir
+      "kamal_lock-#{config.service}"
+    end
+
+    def lock_details_file
+      [lock_dir, :details].join("/")
+    end
+
+    def lock_details(message, version)
+      <<~DETAILS.strip
+        Locked by: #{locked_by} at #{Time.now.utc.iso8601}
+        Version: #{version}
+        Message: #{message}
+      DETAILS
+    end
+
+    def locked_by
+      `git config user.name`.strip
+    rescue Errno::ENOENT
+      "Unknown"
+    end
+end

lib/kamal/commands/prune.rb

@@ -0,0 +1,38 @@
+require "active_support/duration"
+require "active_support/core_ext/numeric/time"
+
+class Kamal::Commands::Prune < Kamal::Commands::Base
+  def dangling_images
+    docker :image, :prune, "--force", "--filter", "label=service=#{config.service}", "--filter", "dangling=true"
+  end
+
+  def tagged_images
+    pipe \
+      docker(:image, :ls, *service_filter, "--format", "'{{.ID}} {{.Repository}}:{{.Tag}}'"),
+      "grep -v -w \"#{active_image_list}\"",
+      "while read image tag; do docker rmi $tag; done"
+  end
+
+  def containers(keep_last: 5)
+    pipe \
+      docker(:ps, "-q", "-a", *service_filter, *stopped_containers_filters),
+      "tail -n +#{keep_last + 1}",
+      "while read container_id; do docker rm $container_id; done"
+  end
+
+  private
+    def stopped_containers_filters
+      [ "created", "exited", "dead" ].flat_map { |status| ["--filter", "status=#{status}"] }
+    end
+
+    def active_image_list
+      # Pull the images that are used by any containers
+      # Append repo:latest - to avoid deleting the latest tag
+      # Append repo:<none> - to avoid deleting dangling images that are in use. Unused dangling images are deleted separately
+      "$(docker container ls -a --format '{{.Image}}\\|' --filter label=service=#{config.service} | tr -d '\\n')#{config.latest_image}\\|#{config.repository}:<none>"
+    end
+
+    def service_filter
+      [ "--filter", "label=service=#{config.service}" ]
+    end
+end

lib/kamal/commands/registry.rb

@@ -0,0 +1,20 @@
+class Kamal::Commands::Registry < Kamal::Commands::Base
+  delegate :registry, to: :config
+
+  def login
+    docker :login, registry["server"], "-u", sensitive(lookup("username")), "-p", sensitive(lookup("password"))
+  end
+
+  def logout
+    docker :logout, registry["server"]
+  end
+
+  private
+    def lookup(key)
+      if registry[key].is_a?(Array)
+        ENV.fetch(registry[key].first).dup
+      else
+        registry[key]
+      end
+    end
+end

lib/kamal/commands/traefik.rb

@@ -0,0 +1,104 @@
+class Kamal::Commands::Traefik < Kamal::Commands::Base
+  delegate :argumentize, :argumentize_env_with_secrets, :optionize, to: Kamal::Utils
+
+  DEFAULT_IMAGE = "traefik:v2.9"
+  CONTAINER_PORT = 80
+  DEFAULT_ARGS = {
+    'log.level' => 'DEBUG'
+  }
+
+  def run
+    docker :run, "--name traefik",
+      "--detach",
+      "--restart", "unless-stopped",
+      "--publish", port,
+      "--volume", "/var/run/docker.sock:/var/run/docker.sock",
+      *env_args,
+      *config.logging_args,
+      *label_args,
+      *docker_options_args,
+      image,
+      "--providers.docker",
+      *cmd_option_args
+  end
+
+  def start
+    docker :container, :start, "traefik"
+  end
+
+  def stop
+    docker :container, :stop, "traefik"
+  end
+
+  def start_or_run
+    combine start, run, by: "||"
+  end
+
+  def info
+    docker :ps, "--filter", "name=^traefik$"
+  end
+
+  def logs(since: nil, lines: nil, grep: nil)
+    pipe \
+      docker(:logs, "traefik", (" --since #{since}" if since), (" --tail #{lines}" if lines), "--timestamps", "2>&1"),
+      ("grep '#{grep}'" if grep)
+  end
+
+  def follow_logs(host:, grep: nil)
+    run_over_ssh pipe(
+      docker(:logs, "traefik", "--timestamps", "--tail", "10", "--follow", "2>&1"),
+      (%(grep "#{grep}") if grep)
+    ).join(" "), host: host
+  end
+
+  def remove_container
+    docker :container, :prune, "--force", "--filter", "label=org.opencontainers.image.title=Traefik"
+  end
+
+  def remove_image
+    docker :image, :prune, "--all", "--force", "--filter", "label=org.opencontainers.image.title=Traefik"
+  end
+
+  def port
+    "#{host_port}:#{CONTAINER_PORT}"
+  end
+
+  private
+    def label_args
+      argumentize "--label", labels
+    end
+
+    def env_args
+      env_config = config.traefik["env"] || {}
+
+      if env_config.present?
+        argumentize_env_with_secrets(env_config)
+      else
+        []
+      end
+    end
+
+    def labels
+      config.traefik["labels"] || []
+    end
+
+    def image
+      config.traefik.fetch("image") { DEFAULT_IMAGE }
+    end
+
+    def docker_options_args
+      optionize(config.traefik["options"] || {})
+    end
+
+    def cmd_option_args
+      if args = config.traefik["args"]
+        optionize DEFAULT_ARGS.merge(args), with: "="
+      else
+        optionize DEFAULT_ARGS, with: "="
+      end
+    end
+
+    def host_port
+      config.traefik["host_port"] || CONTAINER_PORT
+    end
+end

lib/kamal/configuration.rb

@@ -0,0 +1,251 @@
+require "active_support/ordered_options"
+require "active_support/core_ext/string/inquiry"
+require "active_support/core_ext/module/delegation"
+require "pathname"
+require "erb"
+require "net/ssh/proxy/jump"
+
+class Kamal::Configuration
+  delegate :service, :image, :servers, :env, :labels, :registry, :stop_wait_time, :hooks_path, to: :raw_config, allow_nil: true
+  delegate :argumentize, :argumentize_env_with_secrets, :optionize, to: Kamal::Utils
+
+  attr_accessor :destination
+  attr_accessor :raw_config
+
+  class << self
+    def create_from(config_file:, destination: nil, version: nil)
+      raw_config = load_config_files(config_file, *destination_config_file(config_file, destination))
+
+      new raw_config, destination: destination, version: version
+    end
+
+    private
+      def load_config_files(*files)
+        files.inject({}) { |config, file| config.deep_merge! load_config_file(file) }
+      end
+
+      def load_config_file(file)
+        if file.exist?
+          YAML.load(ERB.new(IO.read(file)).result).symbolize_keys
+        else
+          raise "Configuration file not found in #{file}"
+        end
+      end
+
+      def destination_config_file(base_config_file, destination)
+        base_config_file.sub_ext(".#{destination}.yml") if destination
+      end
+  end
+
+  def initialize(raw_config, destination: nil, version: nil, validate: true)
+    @raw_config = ActiveSupport::InheritableOptions.new(raw_config)
+    @destination = destination
+    @declared_version = version
+    valid? if validate
+  end
+
+
+  def version=(version)
+    @declared_version = version
+  end
+
+  def version
+    @declared_version.presence || ENV["VERSION"] || git_version
+  end
+
+  def abbreviated_version
+    Kamal::Utils.abbreviate_version(version)
+  end
+
+
+  def roles
+    @roles ||= role_names.collect { |role_name| Role.new(role_name, config: self) }
+  end
+
+  def role(name)
+    roles.detect { |r| r.name == name.to_s }
+  end
+
+  def accessories
+    @accessories ||= raw_config.accessories&.keys&.collect { |name| Kamal::Configuration::Accessory.new(name, config: self) } || []
+  end
+
+  def accessory(name)
+    accessories.detect { |a| a.name == name.to_s }
+  end
+
+
+  def all_hosts
+    roles.flat_map(&:hosts).uniq
+  end
+
+  def primary_web_host
+    role(:web).primary_host
+  end
+
+  def traefik_hosts
+    roles.select(&:running_traefik?).flat_map(&:hosts).uniq
+  end
+
+  def boot
+    Kamal::Configuration::Boot.new(config: self)
+  end
+
+
+  def repository
+    [ raw_config.registry["server"], image ].compact.join("/")
+  end
+
+  def absolute_image
+    "#{repository}:#{version}"
+  end
+
+  def latest_image
+    "#{repository}:latest"
+  end
+
+  def service_with_version
+    "#{service}-#{version}"
+  end
+
+
+  def env_args
+    if raw_config.env.present?
+      argumentize_env_with_secrets(raw_config.env)
+    else
+      []
+    end
+  end
+
+  def volume_args
+    if raw_config.volumes.present?
+      argumentize "--volume", raw_config.volumes
+    else
+      []
+    end
+  end
+
+  def logging_args
+    if raw_config.logging.present?
+      optionize({ "log-driver" => raw_config.logging["driver"] }.compact) +
+        argumentize("--log-opt", raw_config.logging["options"])
+    else
+      argumentize("--log-opt", { "max-size" => "10m" })
+    end
+  end
+
+
+  def ssh
+    Kamal::Configuration::Ssh.new(config: self)
+  end
+
+  def sshkit
+    Kamal::Configuration::Sshkit.new(config: self)
+  end
+
+
+  def healthcheck
+    { "path" => "/up", "port" => 3000, "max_attempts" => 7 }.merge(raw_config.healthcheck || {})
+  end
+
+  def readiness_delay
+    raw_config.readiness_delay || 7
+  end
+
+  def minimum_version
+    raw_config.minimum_version
+  end
+
+  def valid?
+    ensure_required_keys_present && ensure_valid_kamal_version
+  end
+
+
+  def to_h
+    {
+      roles: role_names,
+      hosts: all_hosts,
+      primary_host: primary_web_host,
+      version: version,
+      repository: repository,
+      absolute_image: absolute_image,
+      service_with_version: service_with_version,
+      env_args: env_args,
+      volume_args: volume_args,
+      ssh_options: ssh.to_h,
+      sshkit: sshkit.to_h,
+      builder: builder.to_h,
+      accessories: raw_config.accessories,
+      logging: logging_args,
+      healthcheck: healthcheck
+    }.compact
+  end
+
+  def traefik
+    raw_config.traefik || {}
+  end
+
+  def hooks_path
+    raw_config.hooks_path || ".kamal/hooks"
+  end
+
+  def builder
+    Kamal::Configuration::Builder.new(config: self)
+  end
+
+  # Will raise KeyError if any secret ENVs are missing
+  def ensure_env_available
+    env_args
+    roles.each(&:env_args)
+
+    true
+  end
+
+  private
+    # Will raise ArgumentError if any required config keys are missing
+    def ensure_required_keys_present
+      %i[ service image registry servers ].each do |key|
+        raise ArgumentError, "Missing required configuration for #{key}" unless raw_config[key].present?
+      end
+
+      if raw_config.registry["username"].blank?
+        raise ArgumentError, "You must specify a username for the registry in config/deploy.yml"
+      end
+
+      if raw_config.registry["password"].blank?
+        raise ArgumentError, "You must specify a password for the registry in config/deploy.yml (or set the ENV variable if that's used)"
+      end
+
+      roles.each do |role|
+        if role.hosts.empty?
+          raise ArgumentError, "No servers specified for the #{role.name} role"
+        end
+      end
+
+      true
+    end
+
+    def ensure_valid_kamal_version
+      if minimum_version && Gem::Version.new(minimum_version) > Gem::Version.new(Kamal::VERSION)
+        raise ArgumentError, "Current version is #{Kamal::VERSION}, minimum required is #{minimum_version}"
+      end
+
+      true
+    end
+
+
+    def role_names
+      raw_config.servers.is_a?(Array) ? [ "web" ] : raw_config.servers.keys.sort
+    end
+
+    def git_version
+      @git_version ||=
+        if system("git rev-parse")
+          uncommitted_suffix = Kamal::Utils.uncommitted_changes.present? ? "_uncommitted_#{SecureRandom.hex(8)}" : ""
+
+          "#{`git rev-parse HEAD`.strip}#{uncommitted_suffix}"
+        else
+          raise "Can't use commit hash as version, no git repository found in #{Dir.pwd}"
+        end
+    end
+end

lib/kamal/configuration/accessory.rb

@@ -0,0 +1,169 @@
+class Kamal::Configuration::Accessory
+  delegate :argumentize, :argumentize_env_with_secrets, :optionize, to: Kamal::Utils
+
+  attr_accessor :name, :specifics
+
+  def initialize(name, config:)
+    @name, @config, @specifics = name.inquiry, config, config.raw_config["accessories"][name]
+  end
+
+  def service_name
+    "#{config.service}-#{name}"
+  end
+
+  def image
+    specifics["image"]
+  end
+
+  def hosts
+    if (specifics.keys & ["host", "hosts", "roles"]).size != 1
+      raise ArgumentError, "Specify one of `host`, `hosts` or `roles` for accessory `#{name}`"
+    end
+
+    hosts_from_host || hosts_from_hosts || hosts_from_roles
+  end
+
+  def port
+    if port = specifics["port"]&.to_s
+      port.include?(":") ? port : "#{port}:#{port}"
+    end
+  end
+
+  def publish_args
+    argumentize "--publish", port if port
+  end
+
+  def labels
+    default_labels.merge(specifics["labels"] || {})
+  end
+
+  def label_args
+    argumentize "--label", labels
+  end
+
+  def env
+    specifics["env"] || {}
+  end
+
+  def env_args
+    argumentize_env_with_secrets env
+  end
+
+  def files
+    specifics["files"]&.to_h do |local_to_remote_mapping|
+      local_file, remote_file = local_to_remote_mapping.split(":")
+      [ expand_local_file(local_file), expand_remote_file(remote_file) ]
+    end || {}
+  end
+
+  def directories
+    specifics["directories"]&.to_h do |host_to_container_mapping|
+      host_relative_path, container_path = host_to_container_mapping.split(":")
+      [ expand_host_path(host_relative_path), container_path ]
+    end || {}
+  end
+
+  def volumes
+    specific_volumes + remote_files_as_volumes + remote_directories_as_volumes
+  end
+
+  def volume_args
+    argumentize "--volume", volumes
+  end
+
+  def option_args
+    if args = specifics["options"]
+      optionize args
+    else
+      []
+    end
+  end
+
+  def cmd
+    specifics["cmd"]
+  end
+
+  private
+    attr_accessor :config
+
+    def default_labels
+      { "service" => service_name }
+    end
+
+    def expand_local_file(local_file)
+      if local_file.end_with?("erb")
+        with_clear_env_loaded { read_dynamic_file(local_file) }
+      else
+        Pathname.new(File.expand_path(local_file)).to_s
+      end
+    end
+
+    def with_clear_env_loaded
+      (env["clear"] || env).each { |k, v| ENV[k] = v }
+      yield
+    ensure
+      (env["clear"] || env).each { |k, v| ENV.delete(k) }
+    end
+
+    def read_dynamic_file(local_file)
+      StringIO.new(ERB.new(IO.read(local_file)).result)
+    end
+
+    def expand_remote_file(remote_file)
+      service_name + remote_file
+    end
+
+    def specific_volumes
+      specifics["volumes"] || []
+    end
+
+    def remote_files_as_volumes
+      specifics["files"]&.collect do |local_to_remote_mapping|
+        _, remote_file = local_to_remote_mapping.split(":")
+        "#{service_data_directory + remote_file}:#{remote_file}"
+      end || []
+    end
+
+    def remote_directories_as_volumes
+      specifics["directories"]&.collect do |host_to_container_mapping|
+        host_relative_path, container_path = host_to_container_mapping.split(":")
+        [ expand_host_path(host_relative_path), container_path ].join(":")
+      end || []
+    end
+
+    def expand_host_path(host_relative_path)
+      "#{service_data_directory}/#{host_relative_path}"
+    end
+
+    def service_data_directory
+      "$PWD/#{service_name}"
+    end
+
+    def hosts_from_host
+      if specifics.key?("host")
+        host = specifics["host"]
+        if host
+          [host]
+        else
+          raise ArgumentError, "Missing host for accessory `#{name}`"
+        end
+      end
+    end
+
+    def hosts_from_hosts
+      if specifics.key?("hosts")
+        hosts = specifics["hosts"]
+        if hosts.is_a?(Array)
+          hosts
+        else
+          raise ArgumentError, "Hosts should be an Array for accessory `#{name}`"
+        end
+      end
+    end
+
+    def hosts_from_roles
+      if specifics.key?("roles")
+        specifics["roles"].flat_map { |role| config.role(role).hosts }
+      end
+    end
+end

lib/kamal/configuration/boot.rb

@@ -0,0 +1,20 @@
+class Kamal::Configuration::Boot
+  def initialize(config:)
+    @options = config.raw_config.boot || {}
+    @host_count = config.all_hosts.count
+  end
+
+  def limit
+    limit = @options["limit"]
+
+    if limit.to_s.end_with?("%")
+      @host_count * limit.to_i / 100
+    else
+      limit
+    end
+  end
+
+  def wait
+    @options["wait"]
+  end
+end

lib/kamal/configuration/builder.rb

@@ -0,0 +1,114 @@
+class Kamal::Configuration::Builder
+  def initialize(config:)
+    @options = config.raw_config.builder || {}
+    @image = config.image
+    @server = config.registry["server"]
+
+    valid?
+  end
+
+  def to_h
+    @options
+  end
+
+  def multiarch?
+    @options["multiarch"] != false
+  end
+
+  def local?
+    !!@options["local"]
+  end
+
+  def remote?
+    !!@options["remote"]
+  end
+
+  def cached?
+    !!@options["cache"]
+  end
+
+  def args
+    @options["args"] || {}
+  end
+
+  def secrets
+    @options["secrets"] || []
+  end
+
+  def dockerfile
+    @options["dockerfile"] || "Dockerfile"
+  end
+
+  def context
+    @options["context"] || "."
+  end
+
+  def local_arch
+    @options["local"]["arch"] if local?
+  end
+
+  def local_host
+    @options["local"]["host"] if local?
+  end
+
+  def remote_arch
+    @options["remote"]["arch"] if remote?
+  end
+
+  def remote_host
+    @options["remote"]["host"] if remote?
+  end
+
+  def cache_from
+    if cached?
+      case @options["cache"]["type"]
+      when "gha"
+        cache_from_config_for_gha
+      when "registry"
+        cache_from_config_for_registry
+      end
+    end
+  end
+
+  def cache_to
+    if cached?
+      case @options["cache"]["type"]
+      when "gha"
+        cache_to_config_for_gha
+      when "registry"
+        cache_to_config_for_registry
+      end
+    end
+  end
+
+  private
+    def valid?
+      if @options["cache"] && @options["cache"]["type"]
+        raise ArgumentError, "Invalid cache type: #{@options["cache"]["type"]}" unless ["gha", "registry"].include?(@options["cache"]["type"])
+      end
+    end
+
+    def cache_image
+      @options["cache"]&.fetch("image", nil) || "#{@image}-build-cache"
+    end
+
+    def cache_image_ref
+      [ @server, cache_image ].compact.join("/")
+    end
+
+    def cache_from_config_for_gha
+      "type=gha"
+    end
+
+    def cache_from_config_for_registry
+      [ "type=registry", "ref=#{cache_image_ref}" ].compact.join(",")
+    end
+
+    def cache_to_config_for_gha
+      [ "type=gha", @options["cache"]&.fetch("options", nil)].compact.join(",")
+    end
+
+    def cache_to_config_for_registry
+      [ "type=registry", @options["cache"]&.fetch("options", nil), "ref=#{cache_image_ref}" ].compact.join(",")
+    end
+end

lib/kamal/configuration/role.rb

@@ -0,0 +1,155 @@
+class Kamal::Configuration::Role
+  delegate :argumentize, :argumentize_env_with_secrets, :optionize, to: Kamal::Utils
+
+  attr_accessor :name
+
+  def initialize(name, config:)
+   @name, @config = name.inquiry, config
+  end
+
+  def primary_host
+    hosts.first
+  end
+
+  def hosts
+    @hosts ||= extract_hosts_from_config
+  end
+
+  def labels
+    default_labels.merge(traefik_labels).merge(custom_labels)
+  end
+
+  def label_args
+    argumentize "--label", labels
+  end
+
+  def env
+    if config.env && config.env["secret"]
+      merged_env_with_secrets
+    else
+      merged_env
+    end
+  end
+
+  def env_args
+    argumentize_env_with_secrets env
+  end
+
+  def health_check_args
+    if health_check_cmd.present?
+      optionize({ "health-cmd" => health_check_cmd, "health-interval" => health_check_interval })
+    else
+      []
+    end
+  end
+
+  def health_check_cmd
+    options = specializations["healthcheck"] || {}
+    options = config.healthcheck.merge(options) if running_traefik?
+
+    options["cmd"] || http_health_check(port: options["port"], path: options["path"])
+  end
+
+  def health_check_interval
+    options = specializations["healthcheck"] || {}
+    options = config.healthcheck.merge(options) if running_traefik?
+
+    options["interval"] || "1s"
+  end
+
+  def cmd
+    specializations["cmd"]
+  end
+
+  def option_args
+    if args = specializations["options"]
+      optionize args
+    else
+      []
+    end
+  end
+
+  def running_traefik?
+    name.web? || specializations["traefik"]
+  end
+
+  private
+    attr_accessor :config
+
+    def extract_hosts_from_config
+      if config.servers.is_a?(Array)
+        config.servers
+      else
+        servers = config.servers[name]
+        servers.is_a?(Array) ? servers : Array(servers["hosts"])
+      end
+    end
+
+    def default_labels
+      if config.destination
+        { "service" => config.service, "role" => name, "destination" => config.destination }
+      else
+        { "service" => config.service, "role" => name }
+      end
+    end
+
+    def traefik_labels
+      if running_traefik?
+        {
+          # Setting a service property ensures that the generated service name will be consistent between versions
+          "traefik.http.services.#{traefik_service}.loadbalancer.server.scheme" => "http",
+
+          "traefik.http.routers.#{traefik_service}.rule" => "PathPrefix(`/`)",
+          "traefik.http.middlewares.#{traefik_service}-retry.retry.attempts" => "5",
+          "traefik.http.middlewares.#{traefik_service}-retry.retry.initialinterval" => "500ms",
+          "traefik.http.routers.#{traefik_service}.middlewares" => "#{traefik_service}-retry@docker"
+        }
+      else
+        {}
+      end
+    end
+
+    def traefik_service
+      [ config.service, name, config.destination ].compact.join("-")
+    end
+
+    def custom_labels
+      Hash.new.tap do |labels|
+        labels.merge!(config.labels) if config.labels.present?
+        labels.merge!(specializations["labels"]) if specializations["labels"].present?
+      end
+    end
+
+    def specializations
+      if config.servers.is_a?(Array) || config.servers[name].is_a?(Array)
+        { }
+      else
+        config.servers[name].except("hosts")
+      end
+    end
+
+    def specialized_env
+      specializations["env"] || {}
+    end
+
+    def merged_env
+      config.env&.merge(specialized_env) || {}
+    end
+
+    # Secrets are stored in an array, which won't merge by default, so have to do it by hand.
+    def merged_env_with_secrets
+      merged_env.tap do |new_env|
+        new_env["secret"] = Array(config.env["secret"]) + Array(specialized_env["secret"])
+
+        # If there's no secret/clear split, everything is clear
+        clear_app_env  = config.env["secret"] ? Array(config.env["clear"]) : Array(config.env["clear"] || config.env)
+        clear_role_env = specialized_env["secret"] ? Array(specialized_env["clear"]) : Array(specialized_env["clear"] || specialized_env)
+
+        new_env["clear"] = (clear_app_env + clear_role_env).uniq
+      end
+    end
+
+    def http_health_check(port:, path:)
+      "curl -f #{URI.join("http://localhost:#{port}", path)} || exit 1" if path.present? || port.present?
+    end
+end

lib/kamal/configuration/ssh.rb

@@ -0,0 +1,38 @@
+class Kamal::Configuration::Ssh
+  LOGGER = ::Logger.new(STDERR)
+
+  def initialize(config:)
+    @config = config.raw_config.ssh || {}
+  end
+
+  def user
+    config.fetch("user", "root")
+  end
+
+  def proxy
+    if (proxy = config["proxy"])
+      Net::SSH::Proxy::Jump.new(proxy.include?("@") ? proxy : "root@#{proxy}")
+    elsif (proxy_command = config["proxy_command"])
+      Net::SSH::Proxy::Command.new(proxy_command)
+    end
+  end
+
+  def options
+    { user: user, proxy: proxy, auth_methods: [ "publickey" ], logger: logger, keepalive: true, keepalive_interval: 30 }.compact
+  end
+
+  def to_h
+    options.except(:logger).merge(log_level: log_level)
+  end
+
+  private
+    attr_accessor :config
+
+    def logger
+      LOGGER.tap { |logger| logger.level = log_level }
+    end
+
+    def log_level
+      config.fetch("log_level", :fatal)
+    end
+end

lib/kamal/configuration/sshkit.rb

@@ -0,0 +1,20 @@
+class Kamal::Configuration::Sshkit
+  def initialize(config:)
+    @options = config.raw_config.sshkit || {}
+  end
+
+  def max_concurrent_starts
+    options.fetch("max_concurrent_starts", 30)
+  end
+
+  def pool_idle_timeout
+    options.fetch("pool_idle_timeout", 900)
+  end
+
+  def to_h
+    options
+  end
+
+  private
+    attr_accessor :options
+end

lib/kamal/sshkit_with_ext.rb

@@ -0,0 +1,104 @@
+require "sshkit"
+require "sshkit/dsl"
+require "active_support/core_ext/hash/deep_merge"
+require "json"
+
+class SSHKit::Backend::Abstract
+  def capture_with_info(*args, **kwargs)
+    capture(*args, **kwargs, verbosity: Logger::INFO)
+  end
+
+  def capture_with_debug(*args, **kwargs)
+    capture(*args, **kwargs, verbosity: Logger::DEBUG)
+  end
+
+  def capture_with_pretty_json(*args, **kwargs)
+    JSON.pretty_generate(JSON.parse(capture(*args, **kwargs)))
+  end
+
+  def puts_by_host(host, output, type: "App")
+    puts "#{type} Host: #{host}\n#{output}\n\n"
+  end
+
+  # Our execution pattern is for the CLI execute args lists returned
+  # from commands, but this doesn't support returning execution options
+  # from the command.
+  #
+  # Support this by using kwargs for CLI options and merging with the
+  # args-extracted options.
+  module CommandEnvMerge
+    private
+
+    # Override to merge options returned by commands in the args list with
+    # options passed by the CLI and pass them along as kwargs.
+    def command(args, options)
+      more_options, args = args.partition { |a| a.is_a? Hash }
+      more_options << options
+
+      build_command(args, **more_options.reduce(:deep_merge))
+    end
+
+    # Destructure options to pluck out env for merge
+    def build_command(args, env: nil, **options)
+      # Rely on native Ruby kwargs precedence rather than explicit Hash merges
+      SSHKit::Command.new(*args, **default_command_options, **options, env: env_for(env))
+    end
+
+    def default_command_options
+      { in: pwd_path, host: @host, user: @user, group: @group }
+    end
+
+    def env_for(env)
+      @env.to_h.merge(env.to_h)
+    end
+  end
+  prepend CommandEnvMerge
+end
+
+class SSHKit::Backend::Netssh::Configuration
+  attr_accessor :max_concurrent_starts
+end
+
+class SSHKit::Backend::Netssh
+  module LimitConcurrentStartsClass
+    attr_reader :start_semaphore
+
+    def configure(&block)
+      super &block
+      # Create this here to avoid lazy creation by multiple threads
+      if config.max_concurrent_starts
+        @start_semaphore = Concurrent::Semaphore.new(config.max_concurrent_starts)
+      end
+    end
+  end
+
+  class << self
+    prepend LimitConcurrentStartsClass
+  end
+
+  module LimitConcurrentStartsInstance
+    private
+      def with_ssh(&block)
+        host.ssh_options = self.class.config.ssh_options.merge(host.ssh_options || {})
+        self.class.pool.with(
+          method(:start_with_concurrency_limit),
+          String(host.hostname),
+          host.username,
+          host.netssh_options,
+          &block
+        )
+      end
+
+      def start_with_concurrency_limit(*args)
+        if self.class.start_semaphore
+          self.class.start_semaphore.acquire do
+            Net::SSH.start(*args)
+          end
+        else
+          Net::SSH.start(*args)
+        end
+      end
+  end
+
+  prepend LimitConcurrentStartsInstance
+end

lib/kamal/tags.rb

@@ -0,0 +1,39 @@
+require "time"
+
+class Kamal::Tags
+  attr_reader :config, :tags
+
+  class << self
+    def from_config(config, **extra)
+      new(**default_tags(config), **extra)
+    end
+
+    def default_tags(config)
+      { recorded_at: Time.now.utc.iso8601,
+        performer: `whoami`.chomp,
+        destination: config.destination,
+        version: config.version,
+        service_version: service_version(config) }
+    end
+
+    def service_version(config)
+      [ config.service, config.abbreviated_version ].compact.join("@")
+    end
+  end
+
+  def initialize(**tags)
+    @tags = tags.compact
+  end
+
+  def env
+    tags.transform_keys { |detail| "KAMAL_#{detail.upcase}" }
+  end
+
+  def to_s
+    tags.values.map { |value| "[#{value}]" }.join(" ")
+  end
+
+  def except(*tags)
+    self.class.new(**self.tags.except(*tags))
+  end
+end

lib/kamal/utils.rb

@@ -0,0 +1,100 @@
+module Kamal::Utils
+  extend self
+
+  DOLLAR_SIGN_WITHOUT_SHELL_EXPANSION_REGEX = /\$(?!{[^\}]*\})/
+
+  # Return a list of escaped shell arguments using the same named argument against the passed attributes (hash or array).
+  def argumentize(argument, attributes, sensitive: false)
+    Array(attributes).flat_map do |key, value|
+      if value.present?
+        attr = "#{key}=#{escape_shell_value(value)}"
+        attr = self.sensitive(attr, redaction: "#{key}=[REDACTED]") if sensitive
+        [ argument, attr]
+      else
+        [ argument, key ]
+      end
+    end
+  end
+
+  # Return a list of shell arguments using the same named argument against the passed attributes,
+  # but redacts and expands secrets.
+  def argumentize_env_with_secrets(env)
+    if (secrets = env["secret"]).present?
+      argumentize("-e", secrets.to_h { |key| [ key, ENV.fetch(key) ] }, sensitive: true) + argumentize("-e", env["clear"])
+    else
+      argumentize "-e", env.fetch("clear", env)
+    end
+  end
+
+  # Returns a list of shell-dashed option arguments. If the value is true, it's treated like a value-less option.
+  def optionize(args, with: nil)
+    options = if with
+      flatten_args(args).collect { |(key, value)| value == true ? "--#{key}" : "--#{key}#{with}#{escape_shell_value(value)}" }
+    else
+      flatten_args(args).collect { |(key, value)| [ "--#{key}", value == true ? nil : escape_shell_value(value) ] }
+    end
+
+    options.flatten.compact
+  end
+
+  # Flattens a one-to-many structure into an array of two-element arrays each containing a key-value pair
+  def flatten_args(args)
+    args.flat_map { |key, value| value.try(:map) { |entry| [key, entry] } || [ [ key, value ] ] }
+  end
+
+  # Marks sensitive values for redaction in logs and human-visible output.
+  # Pass `redaction:` to change the default `"[REDACTED]"` redaction, e.g.
+  # `sensitive "#{arg}=#{secret}", redaction: "#{arg}=xxxx"
+  def sensitive(...)
+    Kamal::Utils::Sensitive.new(...)
+  end
+
+  def redacted(value)
+    case
+    when value.respond_to?(:redaction)
+      value.redaction
+    when value.respond_to?(:transform_values)
+      value.transform_values { |value| redacted value }
+    when value.respond_to?(:map)
+      value.map { |element| redacted element }
+    else
+      value
+    end
+  end
+
+  def unredacted(value)
+    case
+    when value.respond_to?(:unredacted)
+      value.unredacted
+    when value.respond_to?(:transform_values)
+      value.transform_values { |value| unredacted value }
+    when value.respond_to?(:map)
+      value.map { |element| unredacted element }
+    else
+      value
+    end
+  end
+
+  # Escape a value to make it safe for shell use.
+  def escape_shell_value(value)
+    value.to_s.dump
+      .gsub(/`/, '\\\\`')
+      .gsub(DOLLAR_SIGN_WITHOUT_SHELL_EXPANSION_REGEX, '\$')
+  end
+
+  # Abbreviate a git revhash for concise display
+  def abbreviate_version(version)
+    if version
+      # Don't abbreviate <sha>_uncommitted_<etc>
+      if version.include?("_")
+        version
+      else
+        version[0...7]
+      end
+    end
+  end
+
+  def uncommitted_changes
+    `git status --porcelain`.strip
+  end
+end

lib/kamal/utils/healthcheck_poller.rb

@@ -0,0 +1,39 @@
+class Kamal::Utils::HealthcheckPoller
+  TRAEFIK_HEALTHY_DELAY = 2
+
+  class HealthcheckError < StandardError; end
+
+  class << self
+    def wait_for_healthy(pause_after_ready: false, &block)
+      attempt = 1
+      max_attempts = KAMAL.config.healthcheck["max_attempts"]
+
+      begin
+        case status = block.call
+        when "healthy"
+          sleep TRAEFIK_HEALTHY_DELAY if pause_after_ready
+        when "running" # No health check configured
+          sleep KAMAL.config.readiness_delay if pause_after_ready
+        else
+          raise HealthcheckError, "container not ready (#{status})"
+        end
+      rescue HealthcheckError => e
+        if attempt <= max_attempts
+          info "#{e.message}, retrying in #{attempt}s (attempt #{attempt}/#{max_attempts})..."
+          sleep attempt
+          attempt += 1
+          retry
+        else
+          raise
+        end
+      end
+
+      info "Container is healthy!"
+    end
+
+    private
+      def info(message)
+        SSHKit.config.output.info(message)
+      end
+  end
+end

lib/kamal/utils/sensitive.rb

@@ -0,0 +1,19 @@
+require "active_support/core_ext/module/delegation"
+
+class Kamal::Utils::Sensitive
+  # So SSHKit knows to redact these values.
+  include SSHKit::Redaction
+
+  attr_reader :unredacted, :redaction
+  delegate :to_s, to: :unredacted
+  delegate :inspect, to: :redaction
+
+  def initialize(value, redaction: "[REDACTED]")
+    @unredacted, @redaction = value, redaction
+  end
+
+  # Sensitive values won't leak into YAML output.
+  def encode_with(coder)
+    coder.represent_scalar nil, redaction
+  end
+end

lib/kamal/version.rb

@@ -0,0 +1,3 @@
+module Kamal
+  VERSION = "0.16.0"
+end

lib/mrsk.rb

@@ -1,8 +0,0 @@
-module Mrsk
-end
-
-require "mrsk/version"
-require "mrsk/engine"
-
-require "mrsk/configuration"
-require "mrsk/commands"

lib/mrsk/commands.rb

@@ -1,13 +0,0 @@
-module Mrsk::Commands
-  class Base
-    attr_accessor :config
-
-    def initialize(config)
-      @config = config
-    end
-  end
-end
-
-require "mrsk/commands/app"
-require "mrsk/commands/traefik"
-require "mrsk/commands/registry"

lib/mrsk/commands/app.rb

@@ -1,22 +0,0 @@
-class Mrsk::Commands::App < Mrsk::Commands::Base
-  def push
-    # TODO: Run 'docker buildx create --use' when needed
-    "docker buildx build --push --platform=linux/amd64,linux/arm64 -t #{config.absolute_image} ."
-  end
-
-  def pull
-    "docker pull #{config.absolute_image}"
-  end
-
-  def start
-    "docker run -d --rm --name #{config.service_with_version} #{config.envs} #{config.labels} #{config.absolute_image}"
-  end
-
-  def stop
-    "docker ps -q --filter label=service=#{config.service} | xargs docker stop"
-  end
-
-  def info
-    "docker ps --filter label=service=#{config.service}"
-  end
-end

lib/mrsk/commands/registry.rb

@@ -1,5 +0,0 @@
-class Mrsk::Commands::Registry < Mrsk::Commands::Base
-  def login
-    "docker login #{config.registry["server"]} -u #{config.registry["username"]} -p #{config.registry["password"]}"
-  end
-end

lib/mrsk/commands/traefik.rb

@@ -1,17 +0,0 @@
-class Mrsk::Commands::Traefik < Mrsk::Commands::Base
-  def start
-    "docker run --name traefik " + 
-      "--rm -d " +
-      "-p 80:80 " +
-      "-v /var/run/docker.sock:/var/run/docker.sock " +
-      "traefik --providers.docker"
-  end
-
-  def stop
-    "docker container stop traefik"
-  end
-
-  def info
-    "docker ps --filter name=traefik"
-  end
-end

lib/mrsk/configuration.rb

@@ -1,78 +0,0 @@
-require "active_support/ordered_options"
-
-class Mrsk::Configuration
-  delegate :service, :image, :env, :registry, :ssh_user, to: :config, allow_nil: true
-
-  def self.load_file(file)
-    if file.exist?
-      new YAML.load_file(file).symbolize_keys
-    else
-      raise "Configuration file not found in #{file}"
-    end
-  end
-
-  def initialize(config)
-    @config = ActiveSupport::InheritableOptions.new(config)
-    ensure_required_keys_present
-  end
-
-  def servers
-    ENV["SERVERS"] || config.servers
-  end
-
-  def version
-    @version ||= ENV["VERSION"] || `git rev-parse HEAD`.strip
-  end
-
-  def absolute_image
-    [ config.registry["server"], image_with_version ].compact.join("/")
-  end
-
-  def image_with_version
-    "#{image}:#{version}"
-  end
-
-  def service_with_version
-    "#{service}-#{version}"
-  end
-
-  def envs
-    parameterize "-e", \
-      { "RAILS_MASTER_KEY" => master_key }.merge(env || {})
-  end
-
-  def labels
-    parameterize "--label", \
-      "service" => service,
-      "traefik.http.routers.#{service}.rule" => "'PathPrefix(`/`)'",
-      "traefik.http.services.#{service}.loadbalancer.healthcheck.path" => "/up",
-      "traefik.http.services.#{service}.loadbalancer.healthcheck.interval" => "1s",
-      "traefik.http.middlewares.#{service}.retry.attempts" => "3",
-      "traefik.http.middlewares.#{service}.retry.initialinterval" => "500ms"
-  end
-
-  def ssh_options
-    { user: config.ssh_user || "root", auth_methods: [ "publickey" ] }
-  end
-
-  private
-    attr_accessor :config
-
-    def ensure_required_keys_present
-      %i[ service image registry ].each do |key|
-        raise ArgumentError, "Missing required configuration for #{key}" unless config[key].present?
-      end
-
-      %w[ username password ].each do |key|
-        raise ArgumentError, "Missing required configuration for registry/#{key}" unless config.registry[key].present?
-      end      
-    end
-
-    def parameterize(param, hash)
-      hash.collect { |k, v| "#{param} #{k}=#{v}" }.join(" ")
-    end
-
-    def master_key
-      ENV["RAILS_MASTER_KEY"] || File.read(Rails.root.join("config/master.key"))
-    end
-end

lib/mrsk/engine.rb

@@ -1,4 +0,0 @@
-module Mrsk
-  class Engine < ::Rails::Engine
-  end
-end

lib/mrsk/version.rb

@@ -1,3 +0,0 @@
-module Mrsk
-  VERSION = "0.0.1"
-end

lib/tasks/mrsk/app.rake

@@ -1,31 +0,0 @@
-require_relative "setup"
-
-app = Mrsk::Commands::App.new(MRSK_CONFIG)
-
-namespace :mrsk do
-  namespace :app do
-    desc "Build and push app image to servers"
-    task :push do
-      run_locally             { execute app.push }
-      on(MRSK_CONFIG.servers) { execute app.pull }
-    end
-
-    desc "Start app on servers"
-    task :start do
-      on(MRSK_CONFIG.servers) { execute app.start }
-    end
-
-    desc "Stop app on servers"
-    task :stop do
-      on(MRSK_CONFIG.servers) { execute app.stop, raise_on_non_zero_exit: false }
-    end
-
-    desc "Restart app on servers"
-    task restart: %i[ stop start ]
-
-    desc "Display information about app containers"
-    task :info do
-      on(MRSK_CONFIG.servers) { |host| puts "Host: #{host}\n" + capture(app.info) + "\n\n" }
-    end
-  end
-end

lib/tasks/mrsk/mrsk.rake

@@ -1,12 +0,0 @@
-namespace :mrsk do
-  desc "Push the latest version of the app, ensure Traefik is running, then restart app"
-  task deploy: [ "app:push", "traefik:start", "app:restart" ]
-
-  desc "Display information about Traefik and app containers"
-  task info: [ "traefik:info", "app:info" ]
-
-  desc "Create config stub"
-  task :init do
-    Rails.root.join("config/deploy.yml")
-  end
-end

lib/tasks/mrsk/registry.rake

@@ -1,13 +0,0 @@
-require_relative "setup"
-
-registry = Mrsk::Commands::Registry.new(MRSK_CONFIG)
-
-namespace :mrsk do
-  namespace :registry do
-    desc "Login to the registry locally and remotely"
-    task :login do
-      run_locally             { execute registry.login }
-      on(MRSK_CONFIG.servers) { execute registry.login }
-    end
-  end
-end

lib/tasks/mrsk/setup.rb

@@ -1,8 +0,0 @@
-require "sshkit"
-require "sshkit/dsl"
-
-include SSHKit::DSL
-
-MRSK_CONFIG = Mrsk::Configuration.load_file(Rails.root.join("config/deploy.yml"))
-
-SSHKit::Backend::Netssh.configure { |ssh| ssh.ssh_options = MRSK_CONFIG.ssh_options }

lib/tasks/mrsk/traefik.rake

@@ -1,25 +0,0 @@
-require_relative "setup"
-
-traefik = Mrsk::Commands::Traefik.new(MRSK_CONFIG)
-
-namespace :mrsk do
-  namespace :traefik do
-    desc "Start Traefik"
-    task :start do
-      on(MRSK_CONFIG.servers) { execute traefik.start, raise_on_non_zero_exit: false }
-    end
-
-    desc "Stop Traefik"
-    task :stop do
-      on(MRSK_CONFIG.servers) { execute traefik.stop, raise_on_non_zero_exit: false }
-    end
-
-    desc "Restart Traefik"
-    task restart: %i[ stop start ]
-
-    desc "Display information about Traefik containers"
-    task :info do
-      on(MRSK_CONFIG.servers) { |host| puts "Host: #{host}\n" + capture(traefik.info) + "\n\n" }
-    end
-  end
-end

mrsk.gemspec

@@ -1,16 +0,0 @@
-require_relative "lib/mrsk/version"
-
-Gem::Specification.new do |spec|
-  spec.name        = "mrsk"
-  spec.version     = Mrsk::VERSION
-  spec.authors     = [ "David Heinemeier Hansson" ]
-  spec.email       = "dhh@hey.com"
-  spec.homepage    = "https://github.com/rails/mrsk"
-  spec.summary     = "Deploy Docker containers with zero downtime to any host."
-  spec.license     = "MIT"
-
-  spec.files = Dir["lib/**/*", "MIT-LICENSE", "README.md"]
-
-  spec.add_dependency "railties", ">= 7.0.0"
-  spec.add_dependency "sshkit", "~> 1.21"
-end

test/cli/accessory_test.rb

@@ -0,0 +1,143 @@
+require_relative "cli_test_case"
+
+class CliAccessoryTest < CliTestCase
+  test "boot" do
+    Kamal::Cli::Accessory.any_instance.expects(:directories).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:upload).with("mysql")
+
+    run_command("boot", "mysql").tap do |output|
+      assert_match /docker login.*on 1.1.1.3/, output
+      assert_match "docker run --name app-mysql --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 3306:3306 -e [REDACTED] -e MYSQL_ROOT_HOST=\"%\" --volume $PWD/app-mysql/etc/mysql/my.cnf:/etc/mysql/my.cnf --volume $PWD/app-mysql/data:/var/lib/mysql --label service=\"app-mysql\" mysql:5.7 on 1.1.1.3", output
+    end
+  end
+
+  test "boot all" do
+    Kamal::Cli::Accessory.any_instance.expects(:directories).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:upload).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:directories).with("redis")
+    Kamal::Cli::Accessory.any_instance.expects(:upload).with("redis")
+
+    run_command("boot", "all").tap do |output|
+      assert_match /docker login.*on 1.1.1.3/, output
+      assert_match /docker login.*on 1.1.1.1/, output
+      assert_match /docker login.*on 1.1.1.2/, output
+      assert_match "docker run --name app-mysql --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 3306:3306 -e [REDACTED] -e MYSQL_ROOT_HOST=\"%\" --volume $PWD/app-mysql/etc/mysql/my.cnf:/etc/mysql/my.cnf --volume $PWD/app-mysql/data:/var/lib/mysql --label service=\"app-mysql\" mysql:5.7 on 1.1.1.3", output
+      assert_match "docker run --name app-redis --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 6379:6379 --volume $PWD/app-redis/data:/data --label service=\"app-redis\" redis:latest on 1.1.1.1", output
+      assert_match "docker run --name app-redis --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 6379:6379 --volume $PWD/app-redis/data:/data --label service=\"app-redis\" redis:latest on 1.1.1.2", output
+    end
+  end
+
+  test "upload" do
+    run_command("upload", "mysql").tap do |output|
+      assert_match "mkdir -p app-mysql/etc/mysql", output
+      assert_match "test/fixtures/files/my.cnf app-mysql/etc/mysql/my.cnf", output
+      assert_match "chmod 755 app-mysql/etc/mysql/my.cnf", output
+    end
+  end
+
+  test "directories" do
+    assert_match "mkdir -p $PWD/app-mysql/data", run_command("directories", "mysql")
+  end
+
+  test "reboot" do
+    Kamal::Commands::Registry.any_instance.expects(:login)
+    Kamal::Cli::Accessory.any_instance.expects(:stop).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:remove_container).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:boot).with("mysql", login: false)
+
+    run_command("reboot", "mysql")
+  end
+
+  test "start" do
+    assert_match "docker container start app-mysql", run_command("start", "mysql")
+  end
+
+  test "stop" do
+    assert_match "docker container stop app-mysql", run_command("stop", "mysql")
+  end
+
+  test "restart" do
+    Kamal::Cli::Accessory.any_instance.expects(:stop).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:start).with("mysql")
+
+    run_command("restart", "mysql")
+  end
+
+  test "details" do
+    assert_match "docker ps --filter label=service=app-mysql", run_command("details", "mysql")
+  end
+
+  test "details with all" do
+    run_command("details", "all").tap do |output|
+      assert_match "docker ps --filter label=service=app-mysql", output
+      assert_match "docker ps --filter label=service=app-redis", output
+    end
+  end
+
+  test "exec" do
+    run_command("exec", "mysql", "mysql -v").tap do |output|
+      assert_match "Launching command from new container", output
+      assert_match "mysql -v", output
+    end
+  end
+
+  test "exec with reuse" do
+    run_command("exec", "mysql", "--reuse", "mysql -v").tap do |output|
+      assert_match "Launching command from existing container", output
+      assert_match "docker exec app-mysql mysql -v", output
+    end
+  end
+
+  test "logs" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.3 'docker logs app-mysql --timestamps --tail 10 2>&1'")
+
+    assert_match "docker logs app-mysql  --tail 100 --timestamps 2>&1", run_command("logs", "mysql")
+  end
+
+  test "logs with follow" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.3 'docker logs app-mysql --timestamps --tail 10 --follow 2>&1'")
+
+    assert_match "docker logs app-mysql --timestamps --tail 10 --follow 2>&1", run_command("logs", "mysql", "--follow")
+  end
+
+  test "remove with confirmation" do
+    Kamal::Cli::Accessory.any_instance.expects(:stop).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:remove_container).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:remove_image).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:remove_service_directory).with("mysql")
+
+    run_command("remove", "mysql", "-y")
+  end
+
+  test "remove all with confirmation" do
+    Kamal::Cli::Accessory.any_instance.expects(:stop).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:remove_container).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:remove_image).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:remove_service_directory).with("mysql")
+    Kamal::Cli::Accessory.any_instance.expects(:stop).with("redis")
+    Kamal::Cli::Accessory.any_instance.expects(:remove_container).with("redis")
+    Kamal::Cli::Accessory.any_instance.expects(:remove_image).with("redis")
+    Kamal::Cli::Accessory.any_instance.expects(:remove_service_directory).with("redis")
+
+    run_command("remove", "all", "-y")
+  end
+
+  test "remove_container" do
+    assert_match "docker container prune --force --filter label=service=app-mysql", run_command("remove_container", "mysql")
+  end
+
+  test "remove_image" do
+    assert_match "docker image rm --force mysql", run_command("remove_image", "mysql")
+  end
+
+  test "remove_service_directory" do
+    assert_match "rm -rf app-mysql", run_command("remove_service_directory", "mysql")
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Kamal::Cli::Accessory.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/app_test.rb

@@ -0,0 +1,189 @@
+require_relative "cli_test_case"
+
+class CliAppTest < CliTestCase
+  test "boot" do
+    stub_running
+    run_command("boot").tap do |output|
+      assert_match "docker tag dhh/app:latest dhh/app:latest", output
+      assert_match /docker run --detach --restart unless-stopped --name app-web-latest --hostname 1.1.1.1-[0-9a-f]{12} /, output
+      assert_match "docker container ls --all --filter name=^app-web-123$ --quiet | xargs docker stop", output
+    end
+  end
+
+  test "boot will rename if same version is already running" do
+    run_command("details") # Preheat Kamal const
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :container, :ls, "--filter", "name=^app-web-latest$", "--quiet", raise_on_non_zero_exit: false)
+      .returns("12345678") # running version
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^app-web-latest$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+      .returns("running") # health check
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :ps, "--filter", "label=service=app", "--filter", "label=role=web", "--filter", "status=running", "--filter", "status=restarting", "--latest", "--format", "\"{{.Names}}\"", "|", "while read line; do echo ${line#app-web-}; done", raise_on_non_zero_exit: false)
+      .returns("123") # old version
+
+    run_command("boot").tap do |output|
+      assert_match /Renaming container .* to .* as already deployed on 1.1.1.1/, output # Rename
+      assert_match /docker rename app-web-latest app-web-latest_replaced_[0-9a-f]{16}/, output
+      assert_match /docker run --detach --restart unless-stopped --name app-web-latest --hostname 1.1.1.1-[0-9a-f]{12} /, output
+      assert_match "docker container ls --all --filter name=^app-web-123$ --quiet | xargs docker stop", output
+    end
+  ensure
+    Thread.report_on_exception = true
+  end
+
+  test "boot uses group strategy when specified" do
+    Kamal::Cli::App.any_instance.stubs(:on).with("1.1.1.1").twice # acquire & release lock
+    Kamal::Cli::App.any_instance.stubs(:on).with([ "1.1.1.1" ]) # tag container
+
+    # Strategy is used when booting the containers
+    Kamal::Cli::App.any_instance.expects(:on).with([ "1.1.1.1" ], in: :groups, limit: 3, wait: 2).with_block_given
+
+    run_command("boot", config: :with_boot_strategy)
+  end
+
+  test "boot errors leave lock in place" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999" }
+
+    Kamal::Cli::App.any_instance.expects(:using_version).raises(RuntimeError)
+
+    assert !KAMAL.holding_lock?
+    assert_raises(RuntimeError) do
+      stderred { run_command("boot") }
+    end
+    assert KAMAL.holding_lock?
+  end
+
+  test "start" do
+    run_command("start").tap do |output|
+      assert_match "docker start app-web-999", output
+    end
+  end
+
+  test "stop" do
+    run_command("stop").tap do |output|
+      assert_match "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker stop", output
+    end
+  end
+
+  test "stale_containers" do
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :ps, "--filter", "label=service=app", "--filter", "label=role=web", "--format", "\"{{.Names}}\"", "|", "while read line; do echo ${line#app-web-}; done", raise_on_non_zero_exit: false)
+      .returns("12345678\n87654321")
+
+    run_command("stale_containers").tap do |output|
+      assert_match /Detected stale container for role web with version 87654321/, output
+    end
+  end
+
+  test "stop stale_containers" do
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :ps, "--filter", "label=service=app", "--filter", "label=role=web", "--format", "\"{{.Names}}\"", "|", "while read line; do echo ${line#app-web-}; done", raise_on_non_zero_exit: false)
+      .returns("12345678\n87654321")
+
+    run_command("stale_containers", "--stop").tap do |output|
+      assert_match /Stopping stale container for role web with version 87654321/, output
+      assert_match /#{Regexp.escape("docker container ls --all --filter name=^app-web-87654321$ --quiet | xargs docker stop")}/, output
+    end
+  end
+
+  test "details" do
+    run_command("details").tap do |output|
+      assert_match "docker ps --filter label=service=app --filter label=role=web", output
+    end
+  end
+
+  test "remove" do
+    run_command("remove").tap do |output|
+      assert_match /#{Regexp.escape("docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker stop")}/, output
+      assert_match /#{Regexp.escape("docker container prune --force --filter label=service=app")}/, output
+      assert_match /#{Regexp.escape("docker image prune --all --force --filter label=service=app")}/, output
+    end
+  end
+
+  test "remove_container" do
+    run_command("remove_container", "1234567").tap do |output|
+      assert_match "docker container ls --all --filter name=^app-web-1234567$ --quiet | xargs docker container rm", output
+    end
+  end
+
+  test "remove_containers" do
+    run_command("remove_containers").tap do |output|
+      assert_match "docker container prune --force --filter label=service=app", output
+    end
+  end
+
+  test "remove_images" do
+    run_command("remove_images").tap do |output|
+      assert_match "docker image prune --all --force --filter label=service=app", output
+    end
+  end
+
+  test "exec" do
+    run_command("exec", "ruby -v").tap do |output|
+      assert_match "docker run --rm dhh/app:latest ruby -v", output
+    end
+  end
+
+  test "exec with reuse" do
+    run_command("exec", "--reuse", "ruby -v").tap do |output|
+      assert_match "docker ps --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest --format \"{{.Names}}\" | while read line; do echo ${line#app-web-}; done", output # Get current version
+      assert_match "docker exec app-web-999 ruby -v", output
+    end
+  end
+
+  test "containers" do
+    run_command("containers").tap do |output|
+      assert_match "docker container ls --all --filter label=service=app", output
+    end
+  end
+
+  test "images" do
+    run_command("images").tap do |output|
+      assert_match "docker image ls dhh/app", output
+    end
+  end
+
+  test "logs" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.1 'docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest| xargs docker logs --timestamps --tail 10 2>&1'")
+
+    assert_match "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --tail 100 2>&1", run_command("logs")
+  end
+
+  test "logs with follow" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.1 'docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --timestamps --tail 10 --follow 2>&1'")
+
+    assert_match "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --timestamps --tail 10 --follow 2>&1", run_command("logs", "--follow")
+  end
+
+  test "version" do
+    run_command("version").tap do |output|
+      assert_match "docker ps --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest --format \"{{.Names}}\" | while read line; do echo ${line#app-web-}; done", output
+    end
+  end
+
+
+  test "version through main" do
+    stdouted { Kamal::Cli::Main.start(["app", "version", "-c", "test/fixtures/deploy_with_accessories.yml", "--hosts", "1.1.1.1"]) }.tap do |output|
+      assert_match "docker ps --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest --format \"{{.Names}}\" | while read line; do echo ${line#app-web-}; done", output
+    end
+  end
+
+  private
+    def run_command(*command, config: :with_accessories)
+      stdouted { Kamal::Cli::App.start([*command, "-c", "test/fixtures/deploy_#{config}.yml", "--hosts", "1.1.1.1"]) }
+    end
+
+    def stub_running
+      SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_info).returns("123") # old version
+
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :container, :ls, "--all", "--filter", "name=^app-web-latest$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+        .returns("running") # health check
+    end
+end

test/cli/build_test.rb

@@ -0,0 +1,108 @@
+require_relative "cli_test_case"
+
+class CliBuildTest < CliTestCase
+  test "deliver" do
+    Kamal::Cli::Build.any_instance.expects(:push)
+    Kamal::Cli::Build.any_instance.expects(:pull)
+
+    run_command("deliver")
+  end
+
+  test "push" do
+    Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    hook_variables = { version: 999, service_version: "app@999", hosts: "1.1.1.1,1.1.1.2,1.1.1.3,1.1.1.4", command: "build", subcommand: "push" }
+
+    run_command("push").tap do |output|
+      assert_hook_ran "pre-build", output, **hook_variables
+      assert_match /docker --version && docker buildx version/, output
+      assert_match /docker buildx build --push --platform linux\/amd64,linux\/arm64 --builder kamal-app-multiarch -t dhh\/app:999 -t dhh\/app:latest --label service="app" --file Dockerfile \. as .*@localhost/, output
+    end
+  end
+
+  test "push without builder" do
+    stub_locking
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, "--version", "&&", :docker, :buildx, "version")
+
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with { |*args| args[0..1] == [:docker, :buildx] }
+      .raises(SSHKit::Command::Failed.new("no builder"))
+      .then
+      .returns(true)
+
+    run_command("push").tap do |output|
+      assert_match /Missing compatible builder, so creating a new one first/, output
+    end
+  end
+
+  test "push with no buildx plugin" do
+    stub_locking
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, "--version", "&&", :docker, :buildx, "version")
+      .raises(SSHKit::Command::Failed.new("no buildx"))
+
+    Kamal::Commands::Builder.any_instance.stubs(:native_and_local?).returns(false)
+    assert_raises(Kamal::Cli::Build::BuildError) { run_command("push") }
+  end
+
+  test "push pre-build hook failure" do
+    fail_hook("pre-build")
+
+    assert_raises(Kamal::Cli::HookError) { run_command("push") }
+
+    assert @executions.none? { |args| args[0..2] == [:docker, :buildx, :build] }
+  end
+
+  test "pull" do
+    run_command("pull").tap do |output|
+      assert_match /docker image rm --force dhh\/app:999/, output
+      assert_match /docker pull dhh\/app:999/, output
+    end
+  end
+
+  test "create" do
+    run_command("create").tap do |output|
+      assert_match /docker buildx create --use --name kamal-app-multiarch/, output
+    end
+  end
+
+  test "create with error" do
+    stub_locking
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with { |arg| arg == :docker }
+      .raises(SSHKit::Command::Failed.new("stderr=error"))
+
+    run_command("create").tap do |output|
+      assert_match /Couldn't create remote builder: error/, output
+    end
+  end
+
+  test "remove" do
+    run_command("remove").tap do |output|
+      assert_match /docker buildx rm kamal-app-multiarch/, output
+    end
+  end
+
+  test "details" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture)
+      .with(:docker, :context, :ls, "&&", :docker, :buildx, :ls)
+      .returns("docker builder info")
+
+    run_command("details").tap do |output|
+      assert_match /Builder: multiarch/, output
+      assert_match /docker builder info/, output
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Kamal::Cli::Build.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+
+    def stub_dependency_checks
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with(:docker, "--version", "&&", :docker, :buildx, "version")
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with { |*args| args[0..1] == [:docker, :buildx] }
+    end
+end

test/cli/cli_test_case.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+
+class CliTestCase < ActiveSupport::TestCase
+  setup do
+    ENV["VERSION"]             = "999"
+    ENV["RAILS_MASTER_KEY"]    = "123"
+    ENV["MYSQL_ROOT_PASSWORD"] = "secret123"
+    Object.send(:remove_const, :KAMAL)
+    Object.const_set(:KAMAL, Kamal::Commander.new)
+  end
+
+  teardown do
+    ENV.delete("RAILS_MASTER_KEY")
+    ENV.delete("MYSQL_ROOT_PASSWORD")
+    ENV.delete("VERSION")
+  end
+
+  private
+    def fail_hook(hook)
+      @executions = []
+      Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with { |*args| @executions << args; args != [".kamal/hooks/#{hook}"] }
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with { |*args| args.first == ".kamal/hooks/#{hook}" }
+        .raises(SSHKit::Command::Failed.new("failed"))
+    end
+
+    def stub_locking
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with { |arg1, arg2| arg1 == :mkdir && arg2 == "kamal_lock-app" }
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with { |arg1, arg2| arg1 == :rm && arg2 == "kamal_lock-app/details" }
+    end
+
+    def assert_hook_ran(hook, output, version:, service_version:, hosts:, command:, subcommand: nil, runtime: nil)
+      performer = `whoami`.strip
+
+      assert_match "Running the #{hook} hook...\n", output
+
+      expected = %r{Running\s/usr/bin/env\s\.kamal/hooks/#{hook}\sas\s#{performer}@localhost\n\s
+        DEBUG\s\[[0-9a-f]*\]\sCommand:\s\(\sexport\s
+        KAMAL_RECORDED_AT=\"\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\dZ\"\s
+        KAMAL_PERFORMER=\"#{performer}\"\s
+        KAMAL_VERSION=\"#{version}\"\s
+        KAMAL_SERVICE_VERSION=\"#{service_version}\"\s
+        KAMAL_HOSTS=\"#{hosts}\"\s
+        KAMAL_COMMAND=\"#{command}\"\s
+        #{"KAMAL_SUBCOMMAND=\\\"#{subcommand}\\\"\\s" if subcommand}
+        #{"KAMAL_RUNTIME=\\\"#{runtime}\\\"\\s" if runtime}
+        ;\s/usr/bin/env\s\.kamal/hooks/#{hook} }x
+
+      assert_match expected, output
+    end
+end

test/cli/healthcheck_test.rb

@@ -0,0 +1,71 @@
+require_relative "cli_test_case"
+
+class CliHealthcheckTest < CliTestCase
+  test "perform" do
+    # Prevent expected failures from outputting to terminal
+    Thread.report_on_exception = false
+
+    Kamal::Utils::HealthcheckPoller.stubs(:sleep) # No sleeping when retrying
+
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :stop, raise_on_non_zero_exit: false)
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :run, "--detach", "--name", "healthcheck-app-999", "--publish", "3999:3000", "--label", "service=healthcheck-app", "-e", "KAMAL_CONTAINER_NAME=\"healthcheck-app\"", "--health-cmd", "\"curl -f http://localhost:3000/up || exit 1\"", "--health-interval", "\"1s\"", "dhh/app:999")
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :container, :rm, raise_on_non_zero_exit: false)
+
+    # Fail twice to test retry logic
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_info)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+      .returns("starting")
+      .then
+      .returns("unhealthy")
+      .then
+      .returns("healthy")
+
+    run_command("perform").tap do |output|
+      assert_match "container not ready (starting), retrying in 1s (attempt 1/7)...", output
+      assert_match "container not ready (unhealthy), retrying in 2s (attempt 2/7)...", output
+      assert_match "Container is healthy!", output
+    end
+  end
+
+  test "perform failing to become healthy" do
+    # Prevent expected failures from outputting to terminal
+    Thread.report_on_exception = false
+
+    Kamal::Utils::HealthcheckPoller.stubs(:sleep) # No sleeping when retrying
+
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :stop, raise_on_non_zero_exit: false)
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :run, "--detach", "--name", "healthcheck-app-999", "--publish", "3999:3000", "--label", "service=healthcheck-app", "-e", "KAMAL_CONTAINER_NAME=\"healthcheck-app\"", "--health-cmd", "\"curl -f http://localhost:3000/up || exit 1\"", "--health-interval", "\"1s\"", "dhh/app:999")
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :container, :rm, raise_on_non_zero_exit: false)
+
+    # Continually report unhealthy
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_info)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+      .returns("unhealthy")
+
+    # Capture logs when failing
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_info)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :logs, "--tail", 50, "2>&1")
+      .returns("some log output")
+
+    # Capture container health log when failing
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_pretty_json)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :inspect, "--format",  "'{{json .State.Health}}'")
+      .returns('{"Status":"unhealthy","Log":[{"ExitCode": 1,"Output": "/bin/sh: 1: curl: not found\n"}]}"')
+
+    exception = assert_raises do
+      run_command("perform")
+    end
+    assert_match "container not ready (unhealthy)", exception.message
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Kamal::Cli::Healthcheck.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/lock_test.rb

@@ -0,0 +1,20 @@
+require_relative "cli_test_case"
+
+class CliLockTest < CliTestCase
+  test "status" do
+    run_command("status") do |output|
+      assert_match "stat lock", output
+    end
+  end
+
+  test "release" do
+    run_command("release") do |output|
+      assert_match "rm -rf lock", output
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Kamal::Cli::Lock.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/main_test.rb

@@ -0,0 +1,375 @@
+require_relative "cli_test_case"
+
+class CliMainTest < CliTestCase
+  test "setup" do
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:server:bootstrap")
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:accessory:boot", [ "all" ])
+    Kamal::Cli::Main.any_instance.expects(:deploy)
+
+    run_command("setup")
+  end
+
+  test "deploy" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
+
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:deliver", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:traefik:boot", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:healthcheck:perform", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:boot", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:prune:all", [], invoke_options)
+
+    Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    hook_variables = { version: 999, service_version: "app@999", hosts: "1.1.1.1,1.1.1.2", command: "deploy" }
+
+    run_command("deploy").tap do |output|
+      assert_hook_ran "pre-connect", output, **hook_variables
+      assert_match /Log into image registry/, output
+      assert_match /Build and push app image/, output
+      assert_hook_ran "pre-deploy", output, **hook_variables
+      assert_match /Ensure Traefik is running/, output
+      assert_match /Ensure app can pass healthcheck/, output
+      assert_match /Detect stale containers/, output
+      assert_match /Prune old containers and images/, output
+      assert_hook_ran "post-deploy", output, **hook_variables, runtime: 0
+    end
+  end
+
+  test "deploy with skip_push" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
+
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:pull", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:traefik:boot", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:healthcheck:perform", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:boot", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:prune:all", [], invoke_options)
+
+    run_command("deploy", "--skip_push").tap do |output|
+      assert_match /Acquiring the deploy lock/, output
+      assert_match /Log into image registry/, output
+      assert_match /Pull app image/, output
+      assert_match /Ensure Traefik is running/, output
+      assert_match /Ensure app can pass healthcheck/, output
+      assert_match /Detect stale containers/, output
+      assert_match /Prune old containers and images/, output
+      assert_match /Releasing the deploy lock/, output
+    end
+  end
+
+  test "deploy when locked" do
+    Thread.report_on_exception = false
+
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with { |*arg| arg[0..1] == [:mkdir, 'kamal_lock-app'] }
+      .raises(RuntimeError, "mkdir: cannot create directory ‘kamal_lock-app’: File exists")
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_debug)
+      .with(:stat, 'kamal_lock-app', ">", "/dev/null", "&&", :cat, "kamal_lock-app/details", "|", :base64, "-d")
+
+    assert_raises(Kamal::Cli::LockError) do
+      run_command("deploy")
+    end
+  end
+
+  test "deploy error when locking" do
+    Thread.report_on_exception = false
+
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with { |*arg| arg[0..1] == [:mkdir, 'kamal_lock-app'] }
+      .raises(SocketError, "getaddrinfo: nodename nor servname provided, or not known")
+
+    assert_raises(SSHKit::Runner::ExecuteError) do
+      run_command("deploy")
+    end
+  end
+
+  test "deploy errors during outside section leave remove lock" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
+
+    Kamal::Cli::Main.any_instance.expects(:invoke)
+      .with("kamal:cli:registry:login", [], invoke_options)
+      .raises(RuntimeError)
+
+    assert !KAMAL.holding_lock?
+    assert_raises(RuntimeError) do
+      stderred { run_command("deploy") }
+    end
+    assert !KAMAL.holding_lock?
+  end
+
+  test "deploy with skipped hooks" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => true }
+
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:deliver", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:traefik:boot", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:healthcheck:perform", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:boot", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:prune:all", [], invoke_options)
+
+    run_command("deploy", "--skip_hooks") do
+      refute_match /Running the post-deploy hook.../, output
+    end
+  end
+
+  test "deploy with missing secrets" do
+    assert_raises(KeyError) do
+      run_command("deploy", config_file: "deploy_with_secrets")
+    end
+  end
+
+  test "redeploy" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
+
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:deliver", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:healthcheck:perform", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:boot", [], invoke_options)
+
+    Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+
+    hook_variables = { version: 999, service_version: "app@999", hosts: "1.1.1.1,1.1.1.2", command: "redeploy" }
+
+    run_command("redeploy").tap do |output|
+      assert_hook_ran "pre-connect", output, **hook_variables
+      assert_match /Build and push app image/, output
+      assert_hook_ran "pre-deploy", output, **hook_variables
+      assert_match /Running the pre-deploy hook.../, output
+      assert_match /Ensure app can pass healthcheck/, output
+      assert_hook_ran "post-deploy", output, **hook_variables, runtime: "0"
+    end
+  end
+
+  test "redeploy with skip_push" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
+
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:pull", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:healthcheck:perform", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:boot", [], invoke_options)
+
+    run_command("redeploy", "--skip_push").tap do |output|
+      assert_match /Pull app image/, output
+      assert_match /Ensure app can pass healthcheck/, output
+    end
+  end
+
+  test "rollback bad version" do
+    Thread.report_on_exception = false
+
+    run_command("details") # Preheat Kamal const
+
+    run_command("rollback", "nonsense").tap do |output|
+      assert_match /docker container ls --all --filter name=\^app-web-nonsense\$ --quiet/, output
+      assert_match /The app version 'nonsense' is not available as a container/, output
+    end
+  end
+
+  test "rollback good version" do
+    [ "web", "workers" ].each do |role|
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :container, :ls, "--filter", "name=^app-#{role}-123$", "--quiet", raise_on_non_zero_exit: false)
+        .returns("").at_least_once
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :container, :ls, "--all", "--filter", "name=^app-#{role}-123$", "--quiet")
+        .returns("version-to-rollback\n").at_least_once
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :ps, "--filter", "label=service=app", "--filter", "label=role=#{role}", "--filter", "status=running", "--filter", "status=restarting", "--latest", "--format", "\"{{.Names}}\"", "|", "while read line; do echo ${line#app-#{role}-}; done", raise_on_non_zero_exit: false)
+        .returns("version-to-rollback\n").at_least_once
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :container, :ls, "--all", "--filter", "name=^app-#{role}-123$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+        .returns("running").at_least_once # health check
+    end
+
+    Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    hook_variables = { version: 123, service_version: "app@123", hosts: "1.1.1.1,1.1.1.2,1.1.1.3,1.1.1.4", command: "rollback" }
+
+    run_command("rollback", "123", config_file: "deploy_with_accessories").tap do |output|
+      assert_match "Start container with version 123", output
+      assert_hook_ran "pre-deploy", output, **hook_variables
+      assert_match "docker tag dhh/app:123 dhh/app:latest", output
+      assert_match "docker start app-web-123", output
+      assert_match "docker container ls --all --filter name=^app-web-version-to-rollback$ --quiet | xargs docker stop", output, "Should stop the container that was previously running"
+      assert_hook_ran "post-deploy", output, **hook_variables, runtime: "0"
+    end
+  end
+
+  test "rollback without old version" do
+    Kamal::Cli::Main.any_instance.stubs(:container_available?).returns(true)
+
+    Kamal::Utils::HealthcheckPoller.stubs(:sleep)
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :container, :ls, "--filter", "name=^app-web-123$", "--quiet", raise_on_non_zero_exit: false)
+      .returns("").at_least_once
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :ps, "--filter", "label=service=app", "--filter", "label=role=web", "--filter", "status=running", "--filter", "status=restarting", "--latest", "--format", "\"{{.Names}}\"", "|", "while read line; do echo ${line#app-web-}; done", raise_on_non_zero_exit: false)
+      .returns("").at_least_once
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^app-web-123$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+      .returns("running").at_least_once # health check
+
+    run_command("rollback", "123").tap do |output|
+      assert_match "Start container with version 123", output
+      assert_match "docker start app-web-123 || docker run --detach --restart unless-stopped --name app-web-123", output
+      assert_no_match "docker stop", output
+    end
+  end
+
+  test "details" do
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:traefik:details")
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:details")
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:accessory:details", [ "all" ])
+
+    run_command("details")
+  end
+
+  test "audit" do
+    run_command("audit").tap do |output|
+      assert_match /tail -n 50 kamal-app-audit.log on 1.1.1.1/, output
+      assert_match /App Host: 1.1.1.1/, output
+    end
+  end
+
+  test "config" do
+    run_command("config", config_file: "deploy_simple").tap do |output|
+      config = YAML.load(output)
+
+      assert_equal ["web"], config[:roles]
+      assert_equal ["1.1.1.1", "1.1.1.2"], config[:hosts]
+      assert_equal "999", config[:version]
+      assert_equal "dhh/app", config[:repository]
+      assert_equal "dhh/app:999", config[:absolute_image]
+      assert_equal "app-999", config[:service_with_version]
+    end
+  end
+
+  test "config with roles" do
+    run_command("config", config_file: "deploy_with_roles").tap do |output|
+      config = YAML.load(output)
+
+      assert_equal ["web", "workers"], config[:roles]
+      assert_equal ["1.1.1.1", "1.1.1.2", "1.1.1.3", "1.1.1.4"], config[:hosts]
+      assert_equal "999", config[:version]
+      assert_equal "registry.digitalocean.com/dhh/app", config[:repository]
+      assert_equal "registry.digitalocean.com/dhh/app:999", config[:absolute_image]
+      assert_equal "app-999", config[:service_with_version]
+    end
+  end
+
+  test "config with destination" do
+    run_command("config", "-d", "world", config_file: "deploy_for_dest").tap do |output|
+      config = YAML.load(output)
+
+      assert_equal ["web"], config[:roles]
+      assert_equal ["1.1.1.1", "1.1.1.2"], config[:hosts]
+      assert_equal "999", config[:version]
+      assert_equal "registry.digitalocean.com/dhh/app", config[:repository]
+      assert_equal "registry.digitalocean.com/dhh/app:999", config[:absolute_image]
+      assert_equal "app-999", config[:service_with_version]
+    end
+  end
+
+  test "init" do
+    Pathname.any_instance.expects(:exist?).returns(false).times(3)
+    Pathname.any_instance.stubs(:mkpath)
+    FileUtils.stubs(:mkdir_p)
+    FileUtils.stubs(:cp_r)
+    FileUtils.stubs(:cp)
+
+    run_command("init").tap do |output|
+      assert_match /Created configuration file in config\/deploy.yml/, output
+      assert_match /Created \.env file/, output
+    end
+  end
+
+  test "init with existing config" do
+    Pathname.any_instance.expects(:exist?).returns(true).times(3)
+
+    run_command("init").tap do |output|
+      assert_match /Config file already exists in config\/deploy.yml \(remove first to create a new one\)/, output
+    end
+  end
+
+  test "init with bundle option" do
+    Pathname.any_instance.expects(:exist?).returns(false).times(4)
+    Pathname.any_instance.stubs(:mkpath)
+    FileUtils.stubs(:mkdir_p)
+    FileUtils.stubs(:cp_r)
+    FileUtils.stubs(:cp)
+
+    run_command("init", "--bundle").tap do |output|
+      assert_match /Created configuration file in config\/deploy.yml/, output
+      assert_match /Created \.env file/, output
+      assert_match /Adding Kamal to Gemfile and bundle/, output
+      assert_match /bundle add kamal/, output
+      assert_match /bundle binstubs kamal/, output
+      assert_match /Created binstub file in bin\/kamal/, output
+    end
+  end
+
+  test "init with bundle option and existing binstub" do
+    Pathname.any_instance.expects(:exist?).returns(true).times(4)
+    Pathname.any_instance.stubs(:mkpath)
+    FileUtils.stubs(:mkdir_p)
+    FileUtils.stubs(:cp_r)
+    FileUtils.stubs(:cp)
+
+    run_command("init", "--bundle").tap do |output|
+      assert_match /Config file already exists in config\/deploy.yml \(remove first to create a new one\)/, output
+      assert_match /Binstub already exists in bin\/kamal \(remove first to create a new one\)/, output
+    end
+  end
+
+  test "envify" do
+    File.expects(:read).with(".env.erb").returns("HELLO=<%= 'world' %>")
+    File.expects(:write).with(".env", "HELLO=world", perm: 0600)
+
+    run_command("envify")
+  end
+
+  test "envify with destination" do
+    File.expects(:read).with(".env.staging.erb").returns("HELLO=<%= 'world' %>")
+    File.expects(:write).with(".env.staging", "HELLO=world", perm: 0600)
+
+    run_command("envify", "-d", "staging")
+  end
+
+  test "remove with confirmation" do
+    run_command("remove", "-y", config_file: "deploy_with_accessories").tap do |output|
+      assert_match /docker container stop traefik/, output
+      assert_match /docker container prune --force --filter label=org.opencontainers.image.title=Traefik/, output
+      assert_match /docker image prune --all --force --filter label=org.opencontainers.image.title=Traefik/, output
+
+      assert_match /docker ps --quiet --filter label=service=app | xargs docker stop/, output
+      assert_match /docker container prune --force --filter label=service=app/, output
+      assert_match /docker image prune --all --force --filter label=service=app/, output
+
+      assert_match /docker container stop app-mysql/, output
+      assert_match /docker container prune --force --filter label=service=app-mysql/, output
+      assert_match /docker image rm --force mysql/, output
+      assert_match /rm -rf app-mysql/, output
+
+      assert_match /docker container stop app-redis/, output
+      assert_match /docker container prune --force --filter label=service=app-redis/, output
+      assert_match /docker image rm --force redis/, output
+      assert_match /rm -rf app-redis/, output
+
+      assert_match /docker logout/, output
+    end
+  end
+
+  test "version" do
+    version = stdouted { Kamal::Cli::Main.new.version }
+    assert_equal Kamal::VERSION, version
+  end
+
+  private
+    def run_command(*command, config_file: "deploy_simple")
+      stdouted { Kamal::Cli::Main.start([*command, "-c", "test/fixtures/#{config_file}.yml"]) }
+    end
+end

test/cli/prune_test.rb

@@ -0,0 +1,28 @@
+require_relative "cli_test_case"
+
+class CliPruneTest < CliTestCase
+  test "all" do
+    Kamal::Cli::Prune.any_instance.expects(:containers)
+    Kamal::Cli::Prune.any_instance.expects(:images)
+
+    run_command("all")
+  end
+
+  test "images" do
+    run_command("images").tap do |output|
+      assert_match "docker image prune --force --filter label=service=app --filter dangling=true on 1.1.1.", output
+      assert_match "docker image ls --filter label=service=app --format '{{.ID}} {{.Repository}}:{{.Tag}}' | grep -v -w \"$(docker container ls -a --format '{{.Image}}\\|' --filter label=service=app | tr -d '\\n')dhh/app:latest\\|dhh/app:<none>\" | while read image tag; do docker rmi $tag; done on 1.1.1.", output
+    end
+  end
+
+  test "containers" do
+    run_command("containers").tap do |output|
+      assert_match /docker ps -q -a --filter label=service=app --filter status=created --filter status=exited --filter status=dead | tail -n +6 | while read container_id; do docker rm $container_id; done on 1.1.1.\d/, output
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Kamal::Cli::Prune.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/registry_test.rb

@@ -0,0 +1,21 @@
+require_relative "cli_test_case"
+
+class CliRegistryTest < CliTestCase
+  test "login" do
+    run_command("login").tap do |output|
+      assert_match /docker login -u \[REDACTED\] -p \[REDACTED\] as .*@localhost/, output
+      assert_match /docker login -u \[REDACTED\] -p \[REDACTED\] on 1.1.1.\d/, output
+    end
+  end
+
+  test "logout" do
+    run_command("logout").tap do |output|
+      assert_match /docker logout on 1.1.1.\d/, output
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Kamal::Cli::Registry.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/server_test.rb

@@ -0,0 +1,35 @@
+require_relative "cli_test_case"
+
+class CliServerTest < CliTestCase
+  test "bootstrap already installed" do
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:docker, "-v", raise_on_non_zero_exit: false).returns(true).at_least_once
+
+    assert_equal "", run_command("bootstrap")
+  end
+
+  test "bootstrap install as non-root user" do
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:docker, "-v", raise_on_non_zero_exit: false).returns(false).at_least_once
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with('[ "${EUID:-$(id -u)}" -eq 0 ]', raise_on_non_zero_exit: false).returns(false).at_least_once
+
+    assert_raise RuntimeError, "Docker is not installed on 1.1.1.1, 1.1.1.3, 1.1.1.4, 1.1.1.2 and can't be automatically installed without having root access and the `curl` command available. Install Docker manually: https://docs.docker.com/engine/install/" do
+      run_command("bootstrap")
+    end
+  end
+
+  test "bootstrap install as root user" do
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:docker, "-v", raise_on_non_zero_exit: false).returns(false).at_least_once
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with('[ "${EUID:-$(id -u)}" -eq 0 ]', raise_on_non_zero_exit: false).returns(true).at_least_once
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:curl, "-fsSL", "https://get.docker.com", "|", :sh).at_least_once
+
+    run_command("bootstrap").tap do |output|
+      ("1.1.1.1".."1.1.1.4").map do |host|
+        assert_match "Missing Docker on #{host}. Installing…", output
+      end
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Kamal::Cli::Server.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/traefik_test.rb

@@ -0,0 +1,94 @@
+require_relative "cli_test_case"
+
+class CliTraefikTest < CliTestCase
+  test "boot" do
+    run_command("boot").tap do |output|
+      assert_match "docker login", output
+      assert_match "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{Kamal::Commands::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"", output
+    end
+  end
+
+  test "reboot" do
+    Kamal::Commands::Registry.any_instance.expects(:login).twice
+
+    run_command("reboot").tap do |output|
+      assert_match "docker container stop traefik", output
+      assert_match "docker container prune --force --filter label=org.opencontainers.image.title=Traefik", output
+      assert_match "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{Kamal::Commands::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"", output
+    end
+  end
+
+  test "reboot --rolling" do
+    run_command("reboot", "--rolling").tap do |output|
+      assert_match "Running docker container prune --force --filter label=org.opencontainers.image.title=Traefik on 1.1.1.1", output.lines[3]
+    end
+  end
+
+  test "start" do
+    run_command("start").tap do |output|
+      assert_match "docker container start traefik", output
+    end
+  end
+
+  test "stop" do
+    run_command("stop").tap do |output|
+      assert_match "docker container stop traefik", output
+    end
+  end
+
+  test "restart" do
+    Kamal::Cli::Traefik.any_instance.expects(:stop)
+    Kamal::Cli::Traefik.any_instance.expects(:start)
+
+    run_command("restart")
+  end
+
+  test "details" do
+    run_command("details").tap do |output|
+      assert_match "docker ps --filter name=^traefik$", output
+    end
+  end
+
+  test "logs" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture)
+      .with(:docker, :logs, "traefik", " --tail 100", "--timestamps", "2>&1")
+      .returns("Log entry")
+
+    run_command("logs").tap do |output|
+      assert_match "Traefik Host: 1.1.1.1", output
+      assert_match "Log entry", output
+    end
+  end
+
+  test "logs with follow" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.1 'docker logs traefik --timestamps --tail 10 --follow 2>&1'")
+
+    assert_match "docker logs traefik --timestamps --tail 10 --follow", run_command("logs", "--follow")
+  end
+
+  test "remove" do
+    Kamal::Cli::Traefik.any_instance.expects(:stop)
+    Kamal::Cli::Traefik.any_instance.expects(:remove_container)
+    Kamal::Cli::Traefik.any_instance.expects(:remove_image)
+
+    run_command("remove")
+  end
+
+  test "remove_container" do
+    run_command("remove_container").tap do |output|
+      assert_match "docker container prune --force --filter label=org.opencontainers.image.title=Traefik", output
+    end
+  end
+
+  test "remove_image" do
+    run_command("remove_image").tap do |output|
+      assert_match "docker image prune --all --force --filter label=org.opencontainers.image.title=Traefik", output
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Kamal::Cli::Traefik.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/commander_test.rb

@@ -0,0 +1,79 @@
+require "test_helper"
+
+class CommanderTest < ActiveSupport::TestCase
+  setup do
+    configure_with(:deploy_with_roles)
+  end
+
+  test "lazy configuration" do
+    assert_equal Kamal::Configuration, @kamal.config.class
+  end
+
+  test "overwriting hosts" do
+    assert_equal [ "1.1.1.1", "1.1.1.2", "1.1.1.3", "1.1.1.4" ], @kamal.hosts
+
+    @kamal.specific_hosts = [ "1.1.1.1", "1.1.1.2" ]
+    assert_equal [ "1.1.1.1", "1.1.1.2" ], @kamal.hosts
+  end
+
+  test "filtering hosts by filtering roles" do
+    assert_equal [ "1.1.1.1", "1.1.1.2", "1.1.1.3", "1.1.1.4" ], @kamal.hosts
+
+    @kamal.specific_roles = [ "web" ]
+    assert_equal [ "1.1.1.1", "1.1.1.2" ], @kamal.hosts
+  end
+
+  test "filtering roles" do
+    assert_equal [ "web", "workers" ], @kamal.roles.map(&:name)
+
+    @kamal.specific_roles = [ "workers" ]
+    assert_equal [ "workers" ], @kamal.roles.map(&:name)
+  end
+
+  test "filtering roles by filtering hosts" do
+    assert_equal [ "web", "workers" ], @kamal.roles.map(&:name)
+
+    @kamal.specific_hosts = [ "1.1.1.3" ]
+    assert_equal [ "workers" ], @kamal.roles.map(&:name)
+  end
+
+  test "overwriting hosts with primary" do
+    assert_equal [ "1.1.1.1", "1.1.1.2", "1.1.1.3", "1.1.1.4" ], @kamal.hosts
+
+    @kamal.specific_primary!
+    assert_equal [ "1.1.1.1" ], @kamal.hosts
+  end
+
+  test "primary_host with specific hosts via role" do
+    @kamal.specific_roles = "workers"
+    assert_equal "1.1.1.3", @kamal.primary_host
+  end
+
+  test "roles_on" do
+    assert_equal [ "web" ], @kamal.roles_on("1.1.1.1")
+    assert_equal [ "workers" ], @kamal.roles_on("1.1.1.3")
+  end
+
+  test "default group strategy" do
+    assert_empty @kamal.boot_strategy
+  end
+
+  test "specific limit group strategy" do
+    configure_with(:deploy_with_boot_strategy)
+
+    assert_equal({ in: :groups, limit: 3, wait: 2 }, @kamal.boot_strategy)
+  end
+
+  test "percentage-based group strategy" do
+    configure_with(:deploy_with_percentage_boot_strategy)
+
+    assert_equal({ in: :groups, limit: 1, wait: 2 }, @kamal.boot_strategy)
+  end
+
+  private
+    def configure_with(variant)
+      @kamal = Kamal::Commander.new.tap do |kamal|
+        kamal.configure config_file: Pathname.new(File.expand_path("fixtures/#{variant}.yml", __dir__))
+      end
+    end
+end

test/commands/accessory_test.rb

@@ -0,0 +1,151 @@
+require "test_helper"
+
+class CommandsAccessoryTest < ActiveSupport::TestCase
+  setup do
+    @config = {
+      service: "app", image: "dhh/app", registry: { "server" => "private.registry", "username" => "dhh", "password" => "secret" },
+      servers: [ "1.1.1.1" ],
+      accessories: {
+        "mysql" => {
+          "image" => "private.registry/mysql:8.0",
+          "host" => "1.1.1.5",
+          "port" => "3306",
+          "env" => {
+            "clear" => {
+              "MYSQL_ROOT_HOST" => "%"
+            },
+            "secret" => [
+              "MYSQL_ROOT_PASSWORD"
+            ]
+          }
+        },
+        "redis" => {
+          "image" => "redis:latest",
+          "host" => "1.1.1.6",
+          "port" => "6379:6379",
+          "labels" => {
+            "cache" => true
+          },
+          "env" => {
+            "SOMETHING" => "else"
+          },
+          "volumes" => [
+            "/var/lib/redis:/data"
+          ]
+        },
+        "busybox" => {
+          "image" => "busybox:latest",
+          "host" => "1.1.1.7"
+        }
+      }
+    }
+
+    ENV["MYSQL_ROOT_PASSWORD"] = "secret123"
+  end
+
+  teardown do
+    ENV.delete("MYSQL_ROOT_PASSWORD")
+  end
+
+  test "run" do
+    assert_equal \
+      "docker run --name app-mysql --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 3306:3306 -e MYSQL_ROOT_PASSWORD=\"secret123\" -e MYSQL_ROOT_HOST=\"%\" --label service=\"app-mysql\" private.registry/mysql:8.0",
+      new_command(:mysql).run.join(" ")
+
+    assert_equal \
+      "docker run --name app-redis --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 6379:6379 -e SOMETHING=\"else\" --volume /var/lib/redis:/data --label service=\"app-redis\" --label cache=\"true\" redis:latest",
+      new_command(:redis).run.join(" ")
+
+    assert_equal \
+      "docker run --name app-busybox --detach --restart unless-stopped --log-opt max-size=\"10m\" --label service=\"app-busybox\" busybox:latest",
+      new_command(:busybox).run.join(" ")
+  end
+
+  test "run with logging config" do
+    @config[:logging] = { "driver" => "local", "options" => { "max-size" => "100m", "max-file" => "3" } }
+
+    assert_equal \
+      "docker run --name app-busybox --detach --restart unless-stopped --log-driver \"local\" --log-opt max-size=\"100m\" --log-opt max-file=\"3\" --label service=\"app-busybox\" busybox:latest",
+      new_command(:busybox).run.join(" ")
+  end
+
+  test "start" do
+    assert_equal \
+      "docker container start app-mysql",
+      new_command(:mysql).start.join(" ")
+  end
+
+  test "stop" do
+    assert_equal \
+      "docker container stop app-mysql",
+      new_command(:mysql).stop.join(" ")
+  end
+
+  test "info" do
+    assert_equal \
+      "docker ps --filter label=service=app-mysql",
+      new_command(:mysql).info.join(" ")
+  end
+
+
+  test "execute in new container" do
+    assert_equal \
+      "docker run --rm -e MYSQL_ROOT_PASSWORD=\"secret123\" -e MYSQL_ROOT_HOST=\"%\" private.registry/mysql:8.0 mysql -u root",
+      new_command(:mysql).execute_in_new_container("mysql", "-u", "root").join(" ")
+  end
+
+  test "execute in existing container" do
+    assert_equal \
+      "docker exec app-mysql mysql -u root",
+      new_command(:mysql).execute_in_existing_container("mysql", "-u", "root").join(" ")
+  end
+
+  test "execute in new container over ssh" do
+    new_command(:mysql).stub(:run_over_ssh, ->(cmd) { cmd.join(" ") }) do
+      assert_match %r|docker run -it --rm -e MYSQL_ROOT_PASSWORD=\"secret123\" -e MYSQL_ROOT_HOST=\"%\" private.registry/mysql:8.0 mysql -u root|,
+        new_command(:mysql).execute_in_new_container_over_ssh("mysql", "-u", "root")
+    end
+  end
+
+  test "execute in existing container over ssh" do
+    new_command(:mysql).stub(:run_over_ssh, ->(cmd) { cmd.join(" ") }) do
+      assert_match %r|docker exec -it app-mysql mysql -u root|,
+        new_command(:mysql).execute_in_existing_container_over_ssh("mysql", "-u", "root")
+    end
+  end
+
+
+
+  test "logs" do
+    assert_equal \
+      "docker logs app-mysql --timestamps 2>&1",
+      new_command(:mysql).logs.join(" ")
+
+    assert_equal \
+      "docker logs app-mysql  --since 5m  --tail 100 --timestamps 2>&1 | grep 'thing'",
+      new_command(:mysql).logs(since: "5m", lines: 100, grep: "thing").join(" ")
+  end
+
+  test "follow logs" do
+    assert_equal \
+      "ssh -t root@1.1.1.5 'docker logs app-mysql --timestamps --tail 10 --follow 2>&1'",
+      new_command(:mysql).follow_logs
+  end
+
+  test "remove container" do
+    assert_equal \
+      "docker container prune --force --filter label=service=app-mysql",
+      new_command(:mysql).remove_container.join(" ")
+  end
+
+  test "remove image" do
+    assert_equal \
+      "docker image rm --force private.registry/mysql:8.0",
+      new_command(:mysql).remove_image.join(" ")
+  end
+
+  private
+    def new_command(accessory)
+      Kamal::Commands::Accessory.new(Kamal::Configuration.new(@config), name: accessory)
+    end
+end

test/commands/app_test.rb

@@ -0,0 +1,341 @@
+require "test_helper"
+
+class CommandsAppTest < ActiveSupport::TestCase
+  setup do
+    ENV["RAILS_MASTER_KEY"] = "456"
+
+    @config = { service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ], env: { "secret" => [ "RAILS_MASTER_KEY" ] } }
+  end
+
+  teardown do
+    ENV.delete("RAILS_MASTER_KEY")
+  end
+
+  test "run" do
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e KAMAL_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "run with hostname" do
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 --hostname myhost -e KAMAL_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run(hostname: "myhost").join(" ")
+  end
+
+  test "run with volumes" do
+    @config[:volumes] = ["/local/path:/container/path" ]
+
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e KAMAL_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --volume /local/path:/container/path --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom healthcheck path" do
+    @config[:healthcheck] = { "path" => "/healthz" }
+
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e KAMAL_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/healthz || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom healthcheck command" do
+    @config[:healthcheck] = { "cmd" => "/bin/up" }
+
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e KAMAL_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"/bin/up\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "run with role-specific healthcheck options" do
+    @config[:servers] = { "web" => { "hosts" => [ "1.1.1.1" ], "healthcheck" => { "cmd" => "/bin/healthy" } } }
+
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e KAMAL_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"/bin/healthy\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom options" do
+    @config[:servers] = { "web" => [ "1.1.1.1" ], "jobs" => { "hosts" => [ "1.1.1.2" ], "cmd" => "bin/jobs", "options" => { "mount" => "somewhere", "cap-add" => true } } }
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-jobs-999 -e KAMAL_CONTAINER_NAME=\"app-jobs-999\" -e RAILS_MASTER_KEY=\"456\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"jobs\" --mount \"somewhere\" --cap-add dhh/app:999 bin/jobs",
+      new_command(role: "jobs").run.join(" ")
+  end
+
+  test "run with logging config" do
+    @config[:logging] = { "driver" => "local", "options" => { "max-size" => "100m", "max-file" => "3" } }
+
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e KAMAL_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-driver \"local\" --log-opt max-size=\"100m\" --log-opt max-file=\"3\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "start" do
+    assert_equal \
+      "docker start app-web-999",
+      new_command.start.join(" ")
+  end
+
+  test "start with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker start app-web-staging-999",
+      new_command.start.join(" ")
+  end
+
+  test "start_or_run" do
+    assert_equal \
+      "docker start app-web-999 || docker run --detach --restart unless-stopped --name app-web-999 -e KAMAL_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.start_or_run.join(" ")
+  end
+
+  test "start_or_run with hostname" do
+    assert_equal \
+      "docker start app-web-999 || docker run --detach --restart unless-stopped --name app-web-999 --hostname myhost -e KAMAL_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.start_or_run(hostname: "myhost").join(" ")
+  end
+
+  test "stop" do
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker stop",
+      new_command.stop.join(" ")
+  end
+
+  test "stop with custom stop wait time" do
+    @config[:stop_wait_time] = 30
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker stop -t 30",
+      new_command.stop.join(" ")
+  end
+
+  test "stop with version" do
+    assert_equal \
+      "docker container ls --all --filter name=^app-web-123$ --quiet | xargs docker stop",
+      new_command.stop(version: "123").join(" ")
+  end
+
+  test "info" do
+    assert_equal \
+      "docker ps --filter label=service=app --filter label=role=web",
+      new_command.info.join(" ")
+  end
+
+  test "info with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker ps --filter label=service=app --filter label=destination=staging --filter label=role=web",
+      new_command.info.join(" ")
+  end
+
+
+  test "logs" do
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs 2>&1",
+      new_command.logs.join(" ")
+
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --since 5m 2>&1",
+      new_command.logs(since: "5m").join(" ")
+
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --tail 100 2>&1",
+      new_command.logs(lines: "100").join(" ")
+
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --since 5m --tail 100 2>&1",
+      new_command.logs(since: "5m", lines: "100").join(" ")
+
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs 2>&1 | grep 'my-id'",
+      new_command.logs(grep: "my-id").join(" ")
+
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --since 5m 2>&1 | grep 'my-id'",
+      new_command.logs(since: "5m", grep: "my-id").join(" ")
+  end
+
+  test "follow logs" do
+    assert_match \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --timestamps --tail 10 --follow 2>&1",
+      new_command.follow_logs(host: "app-1")
+
+    assert_match \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --timestamps --tail 10 --follow 2>&1 | grep \"Completed\"",
+      new_command.follow_logs(host: "app-1", grep: "Completed")
+  end
+
+
+  test "execute in new container" do
+    assert_equal \
+      "docker run --rm -e RAILS_MASTER_KEY=\"456\" dhh/app:999 bin/rails db:setup",
+      new_command.execute_in_new_container("bin/rails", "db:setup").join(" ")
+  end
+
+  test "execute in new container with custom options" do
+    @config[:servers] = { "web" => { "hosts" => [ "1.1.1.1" ], "options" => { "mount" => "somewhere", "cap-add" => true } } }
+    assert_equal \
+      "docker run --rm -e RAILS_MASTER_KEY=\"456\" --mount \"somewhere\" --cap-add dhh/app:999 bin/rails db:setup",
+      new_command.execute_in_new_container("bin/rails", "db:setup").join(" ")
+  end
+
+  test "execute in existing container" do
+    assert_equal \
+      "docker exec app-web-999 bin/rails db:setup",
+      new_command.execute_in_existing_container("bin/rails", "db:setup").join(" ")
+  end
+
+  test "execute in new container over ssh" do
+    assert_match %r|docker run -it --rm -e RAILS_MASTER_KEY=\"456\" dhh/app:999 bin/rails c|,
+      new_command.execute_in_new_container_over_ssh("bin/rails", "c", host: "app-1")
+  end
+
+  test "execute in new container with custom options over ssh" do
+    @config[:servers] = { "web" => { "hosts" => [ "1.1.1.1" ], "options" => { "mount" => "somewhere", "cap-add" => true } } }
+    assert_match %r|docker run -it --rm -e RAILS_MASTER_KEY=\"456\" --mount \"somewhere\" --cap-add dhh/app:999 bin/rails c|,
+      new_command.execute_in_new_container_over_ssh("bin/rails", "c", host: "app-1")
+  end
+
+  test "execute in existing container over ssh" do
+    assert_match %r|docker exec -it app-web-999 bin/rails c|,
+      new_command.execute_in_existing_container_over_ssh("bin/rails", "c", host: "app-1")
+  end
+
+  test "run over ssh" do
+    assert_equal "ssh -t root@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "run over ssh with custom user" do
+    @config[:ssh] = { "user" => "app" }
+    assert_equal "ssh -t app@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "run over ssh with proxy" do
+    @config[:ssh] = { "proxy" => "2.2.2.2" }
+    assert_equal "ssh -J root@2.2.2.2 -t root@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "run over ssh with proxy user" do
+    @config[:ssh] = { "proxy" => "app@2.2.2.2" }
+    assert_equal "ssh -J app@2.2.2.2 -t root@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "run over ssh with custom user with proxy" do
+    @config[:ssh] = { "user" => "app", "proxy" => "2.2.2.2" }
+    assert_equal "ssh -J root@2.2.2.2 -t app@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "run over ssh with proxy_command" do
+    @config[:ssh] = { "proxy_command" => "ssh -W %h:%p user@proxy-server" }
+    assert_equal "ssh -o ProxyCommand='ssh -W %h:%p user@proxy-server' -t root@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "current_running_container_id" do
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest",
+      new_command.current_running_container_id.join(" ")
+  end
+
+  test "current_running_container_id with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=destination=staging --filter label=role=web --filter status=running --filter status=restarting --latest",
+      new_command.current_running_container_id.join(" ")
+  end
+
+  test "container_id_for" do
+    assert_equal \
+      "docker container ls --all --filter name=^app-999$ --quiet",
+      new_command.container_id_for(container_name: "app-999").join(" ")
+  end
+
+  test "current_running_version" do
+    assert_equal \
+      "docker ps --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest --format \"{{.Names}}\" | while read line; do echo ${line#app-web-}; done",
+      new_command.current_running_version.join(" ")
+  end
+
+  test "list_versions" do
+    assert_equal \
+      "docker ps --filter label=service=app --filter label=role=web --format \"{{.Names}}\" | while read line; do echo ${line#app-web-}; done",
+      new_command.list_versions.join(" ")
+
+    assert_equal \
+      "docker ps --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest --format \"{{.Names}}\" | while read line; do echo ${line#app-web-}; done",
+      new_command.list_versions("--latest", statuses: [ :running, :restarting ]).join(" ")
+  end
+
+  test "list_containers" do
+    assert_equal \
+      "docker container ls --all --filter label=service=app --filter label=role=web",
+      new_command.list_containers.join(" ")
+  end
+
+  test "list_containers with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker container ls --all --filter label=service=app --filter label=destination=staging --filter label=role=web",
+      new_command.list_containers.join(" ")
+  end
+
+  test "list_container_names" do
+    assert_equal \
+      "docker container ls --all --filter label=service=app --filter label=role=web --format '{{ .Names }}'",
+      new_command.list_container_names.join(" ")
+  end
+
+  test "remove_container" do
+    assert_equal \
+      "docker container ls --all --filter name=^app-web-999$ --quiet | xargs docker container rm",
+      new_command.remove_container(version: "999").join(" ")
+  end
+
+  test "remove_container with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker container ls --all --filter name=^app-web-staging-999$ --quiet | xargs docker container rm",
+      new_command.remove_container(version: "999").join(" ")
+  end
+
+  test "remove_containers" do
+    assert_equal \
+      "docker container prune --force --filter label=service=app --filter label=role=web",
+      new_command.remove_containers.join(" ")
+  end
+
+  test "remove_containers with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker container prune --force --filter label=service=app --filter label=destination=staging --filter label=role=web",
+      new_command.remove_containers.join(" ")
+  end
+
+  test "list_images" do
+    assert_equal \
+      "docker image ls dhh/app",
+      new_command.list_images.join(" ")
+  end
+
+  test "remove_images" do
+    assert_equal \
+      "docker image prune --all --force --filter label=service=app --filter label=role=web",
+      new_command.remove_images.join(" ")
+  end
+
+  test "remove_images with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker image prune --all --force --filter label=service=app --filter label=destination=staging --filter label=role=web",
+      new_command.remove_images.join(" ")
+  end
+
+  test "tag_current_as_latest" do
+    assert_equal \
+      "docker tag dhh/app:999 dhh/app:latest",
+      new_command.tag_current_as_latest.join(" ")
+  end
+
+  private
+    def new_command(role: "web")
+      Kamal::Commands::App.new(Kamal::Configuration.new(@config, destination: @destination, version: "999"), role: role)
+    end
+end

test/commands/auditor_test.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+require "active_support/testing/time_helpers"
+
+class CommandsAuditorTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::TimeHelpers
+
+  setup do
+    freeze_time
+
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ]
+    }
+
+    @auditor = new_command
+    @performer = `whoami`.strip
+    @recorded_at = Time.now.utc.iso8601
+  end
+
+  test "record" do
+    assert_equal [
+      :echo,
+      "[#{@recorded_at}] [#{@performer}]",
+      "app removed container",
+      ">>", "kamal-app-audit.log"
+    ], @auditor.record("app removed container")
+  end
+
+  test "record with destination" do
+    new_command(destination: "staging").tap do |auditor|
+      assert_equal [
+        :echo,
+        "[#{@recorded_at}] [#{@performer}] [staging]",
+        "app removed container",
+        ">>", "kamal-app-staging-audit.log"
+      ], auditor.record("app removed container")
+    end
+  end
+
+  test "record with command details" do
+    new_command(role: "web").tap do |auditor|
+      assert_equal [
+        :echo,
+        "[#{@recorded_at}] [#{@performer}] [web]",
+        "app removed container",
+        ">>", "kamal-app-audit.log"
+      ], auditor.record("app removed container")
+    end
+  end
+
+  test "record with arg details" do
+    assert_equal [
+      :echo,
+      "[#{@recorded_at}] [#{@performer}] [value]",
+      "app removed container",
+      ">>", "kamal-app-audit.log"
+    ], @auditor.record("app removed container", detail: "value")
+  end
+
+
+  private
+    def new_command(destination: nil, **details)
+      Kamal::Commands::Auditor.new(Kamal::Configuration.new(@config, destination: destination, version: "123"), **details)
+    end
+end

test/commands/builder_test.rb

@@ -0,0 +1,110 @@
+require "test_helper"
+
+class CommandsBuilderTest < ActiveSupport::TestCase
+  setup do
+    @config = { service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ] }
+  end
+
+  test "target multiarch by default" do
+    builder = new_builder_command(builder: { "cache" => { "type" => "gha" }})
+    assert_equal "multiarch", builder.name
+    assert_equal \
+      "docker buildx build --push --platform linux/amd64,linux/arm64 --builder kamal-app-multiarch -t dhh/app:123 -t dhh/app:latest --cache-to type=gha --cache-from type=gha --label service=\"app\" --file Dockerfile .",
+      builder.push.join(" ")
+  end
+
+  test "target native when multiarch is off" do
+    builder = new_builder_command(builder: { "multiarch" => false })
+    assert_equal "native", builder.name
+    assert_equal \
+      "docker build -t dhh/app:123 -t dhh/app:latest --label service=\"app\" --file Dockerfile . && docker push dhh/app:123 && docker push dhh/app:latest",
+      builder.push.join(" ")
+  end
+
+  test "target native cached when multiarch is off and cache is set" do
+    builder = new_builder_command(builder: { "multiarch" => false, "cache" => { "type" => "gha" }})
+    assert_equal "native/cached", builder.name
+    assert_equal \
+      "docker buildx build --push -t dhh/app:123 -t dhh/app:latest --cache-to type=gha --cache-from type=gha --label service=\"app\" --file Dockerfile .",
+      builder.push.join(" ")
+  end
+
+  test "target multiarch remote when local and remote is set" do
+    builder = new_builder_command(builder: { "local" => { }, "remote" => { }, "cache" => { "type" => "gha" } })
+    assert_equal "multiarch/remote", builder.name
+    assert_equal \
+      "docker buildx build --push --platform linux/amd64,linux/arm64 --builder kamal-app-multiarch-remote -t dhh/app:123 -t dhh/app:latest --cache-to type=gha --cache-from type=gha --label service=\"app\" --file Dockerfile .",
+      builder.push.join(" ")
+  end
+
+  test "target native remote when only remote is set" do
+    builder = new_builder_command(builder: { "remote" => { "arch" => "amd64" }, "cache" => { "type" => "gha" } })
+    assert_equal "native/remote", builder.name
+    assert_equal \
+      "docker buildx build --push --platform linux/amd64 --builder kamal-app-native-remote -t dhh/app:123 -t dhh/app:latest --cache-to type=gha --cache-from type=gha --label service=\"app\" --file Dockerfile .",
+      builder.push.join(" ")
+  end
+
+  test "build args" do
+    builder = new_builder_command(builder: { "args" => { "a" => 1, "b" => 2 } })
+    assert_equal \
+      "-t dhh/app:123 -t dhh/app:latest --label service=\"app\" --build-arg a=\"1\" --build-arg b=\"2\" --file Dockerfile",
+      builder.target.build_options.join(" ")
+  end
+
+  test "build secrets" do
+    builder = new_builder_command(builder: { "secrets" => ["token_a", "token_b"] })
+    assert_equal \
+      "-t dhh/app:123 -t dhh/app:latest --label service=\"app\" --secret id=\"token_a\" --secret id=\"token_b\" --file Dockerfile",
+      builder.target.build_options.join(" ")
+  end
+
+  test "build dockerfile" do
+    Pathname.any_instance.expects(:exist?).returns(true).once
+    builder = new_builder_command(builder: { "dockerfile" => "Dockerfile.xyz" })
+    assert_equal \
+      "-t dhh/app:123 -t dhh/app:latest --label service=\"app\" --file Dockerfile.xyz",
+      builder.target.build_options.join(" ")
+  end
+
+  test "missing dockerfile" do
+    Pathname.any_instance.expects(:exist?).returns(false).once
+    builder = new_builder_command(builder: { "dockerfile" => "Dockerfile.xyz" })
+    assert_raises(Kamal::Commands::Builder::Base::BuilderError) do
+      builder.target.build_options.join(" ")
+    end
+  end
+
+  test "build context" do
+    builder = new_builder_command(builder: { "context" => ".." })
+    assert_equal \
+      "docker buildx build --push --platform linux/amd64,linux/arm64 --builder kamal-app-multiarch -t dhh/app:123 -t dhh/app:latest --label service=\"app\" --file Dockerfile ..",
+      builder.push.join(" ")
+  end
+
+  test "native push with build args" do
+    builder = new_builder_command(builder: { "multiarch" => false, "args" => { "a" => 1, "b" => 2 } })
+    assert_equal \
+      "docker build -t dhh/app:123 -t dhh/app:latest --label service=\"app\" --build-arg a=\"1\" --build-arg b=\"2\" --file Dockerfile . && docker push dhh/app:123 && docker push dhh/app:latest",
+      builder.push.join(" ")
+  end
+
+  test "multiarch push with build args" do
+    builder = new_builder_command(builder: { "args" => { "a" => 1, "b" => 2 } })
+    assert_equal \
+      "docker buildx build --push --platform linux/amd64,linux/arm64 --builder kamal-app-multiarch -t dhh/app:123 -t dhh/app:latest --label service=\"app\" --build-arg a=\"1\" --build-arg b=\"2\" --file Dockerfile .",
+      builder.push.join(" ")
+  end
+
+  test "native push with build secrets" do
+    builder = new_builder_command(builder: { "multiarch" => false, "secrets" => [ "a", "b" ] })
+    assert_equal \
+      "docker build -t dhh/app:123 -t dhh/app:latest --label service=\"app\" --secret id=\"a\" --secret id=\"b\" --file Dockerfile . && docker push dhh/app:123 && docker push dhh/app:latest",
+      builder.push.join(" ")
+  end
+
+  private
+    def new_builder_command(additional_config = {})
+      Kamal::Commands::Builder.new(Kamal::Configuration.new(@config.merge(additional_config), version: "123"))
+    end
+end

test/commands/docker_test.rb

@@ -0,0 +1,26 @@
+require "test_helper"
+
+class CommandsDockerTest < ActiveSupport::TestCase
+  setup do
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ]
+    }
+    @docker = Kamal::Commands::Docker.new(Kamal::Configuration.new(@config))
+  end
+
+  test "install" do
+    assert_equal "curl -fsSL https://get.docker.com | sh", @docker.install.join(" ")
+  end
+
+  test "installed?" do
+    assert_equal "docker -v", @docker.installed?.join(" ")
+  end
+
+  test "running?" do
+    assert_equal "docker version", @docker.running?.join(" ")
+  end
+
+  test "superuser?" do
+    assert_equal '[ "${EUID:-$(id -u)}" -eq 0 ]', @docker.superuser?.join(" ")
+  end
+end

test/commands/healthcheck_test.rb

@@ -0,0 +1,106 @@
+require "test_helper"
+
+class CommandsHealthcheckTest < ActiveSupport::TestCase
+  setup do
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ],
+      traefik: { "args" => { "accesslog.format" => "json", "metrics.prometheus.buckets" => "0.1,0.3,1.2,5.0" } }
+    }
+  end
+
+  test "run" do
+    assert_equal \
+      "docker run --detach --name healthcheck-app-123 --publish 3999:3000 --label service=healthcheck-app -e KAMAL_CONTAINER_NAME=\"healthcheck-app\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" dhh/app:123",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom port" do
+    @config[:healthcheck] = { "port" => 3001 }
+
+    assert_equal \
+      "docker run --detach --name healthcheck-app-123 --publish 3999:3001 --label service=healthcheck-app -e KAMAL_CONTAINER_NAME=\"healthcheck-app\" --health-cmd \"curl -f http://localhost:3001/up || exit 1\" --health-interval \"1s\" dhh/app:123",
+      new_command.run.join(" ")
+  end
+
+  test "run with destination" do
+    @destination = "staging"
+
+    assert_equal \
+      "docker run --detach --name healthcheck-app-staging-123 --publish 3999:3000 --label service=healthcheck-app-staging -e KAMAL_CONTAINER_NAME=\"healthcheck-app-staging\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" dhh/app:123",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom healthcheck" do
+    @config[:healthcheck] = { "cmd" => "/bin/up" }
+
+    assert_equal \
+      "docker run --detach --name healthcheck-app-123 --publish 3999:3000 --label service=healthcheck-app -e KAMAL_CONTAINER_NAME=\"healthcheck-app\" --health-cmd \"/bin/up\" --health-interval \"1s\" dhh/app:123",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom options" do
+    @config[:servers] = { "web" => { "hosts" => [ "1.1.1.1" ], "options" => { "mount" => "somewhere" } } }
+    assert_equal \
+      "docker run --detach --name healthcheck-app-123 --publish 3999:3000 --label service=healthcheck-app -e KAMAL_CONTAINER_NAME=\"healthcheck-app\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --mount \"somewhere\" dhh/app:123",
+      new_command.run.join(" ")
+  end
+
+  test "status" do
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-123$ --quiet | xargs docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'",
+      new_command.status.join(" ")
+  end
+
+  test "container_health_log" do
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-123$ --quiet | xargs docker inspect --format '{{json .State.Health}}'",
+      new_command.container_health_log.join(" ")
+  end
+
+  test "stop" do
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-123$ --quiet | xargs docker stop",
+      new_command.stop.join(" ")
+  end
+
+  test "stop with destination" do
+    @destination = "staging"
+
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-staging-123$ --quiet | xargs docker stop",
+      new_command.stop.join(" ")
+  end
+
+  test "remove" do
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-123$ --quiet | xargs docker container rm",
+      new_command.remove.join(" ")
+  end
+
+  test "remove with destination" do
+    @destination = "staging"
+
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-staging-123$ --quiet | xargs docker container rm",
+      new_command.remove.join(" ")
+  end
+
+  test "logs" do
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-123$ --quiet | xargs docker logs --tail 50 2>&1",
+      new_command.logs.join(" ")
+  end
+
+  test "logs with destination" do
+    @destination = "staging"
+
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-staging-123$ --quiet | xargs docker logs --tail 50 2>&1",
+      new_command.logs.join(" ")
+  end
+
+  private
+    def new_command
+      Kamal::Commands::Healthcheck.new(Kamal::Configuration.new(@config, destination: @destination, version: "123"))
+    end
+end

test/commands/hook_test.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class CommandsHookTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::TimeHelpers
+
+  setup do
+    freeze_time
+
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ],
+      traefik: { "args" => { "accesslog.format" => "json", "metrics.prometheus.buckets" => "0.1,0.3,1.2,5.0" } }
+    }
+
+    @performer = `whoami`.strip
+    @recorded_at = Time.now.utc.iso8601
+  end
+
+  test "run" do
+    assert_equal [
+      ".kamal/hooks/foo",
+      { env: {
+        "KAMAL_RECORDED_AT" => @recorded_at,
+        "KAMAL_PERFORMER" => @performer,
+        "KAMAL_VERSION" => "123",
+        "KAMAL_SERVICE_VERSION" => "app@123" } }
+    ], new_command.run("foo")
+  end
+
+  test "run with custom hooks_path" do
+    assert_equal [
+      "custom/hooks/path/foo",
+      { env: {
+        "KAMAL_RECORDED_AT" => @recorded_at,
+        "KAMAL_PERFORMER" => @performer,
+        "KAMAL_VERSION" => "123",
+        "KAMAL_SERVICE_VERSION" => "app@123" } }
+    ], new_command(hooks_path: "custom/hooks/path").run("foo")
+  end
+
+  private
+    def new_command(**extra_config)
+      Kamal::Commands::Hook.new(Kamal::Configuration.new(@config.merge(**extra_config), version: "123"))
+    end
+end

test/commands/lock_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class CommandsLockTest < ActiveSupport::TestCase
+  setup do
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ],
+      traefik: { "args" => { "accesslog.format" => "json", "metrics.prometheus.buckets" => "0.1,0.3,1.2,5.0" } }
+    }
+  end
+
+  test "status" do
+    assert_equal \
+      "stat kamal_lock-app > /dev/null && cat kamal_lock-app/details | base64 -d",
+      new_command.status.join(" ")
+  end
+
+  test "acquire" do
+    assert_match \
+      /mkdir kamal_lock-app && echo ".*" > kamal_lock-app\/details/m,
+      new_command.acquire("Hello", "123").join(" ")
+  end
+
+  test "release" do
+    assert_match \
+      "rm kamal_lock-app/details && rm -r kamal_lock-app",
+      new_command.release.join(" ")
+  end
+
+  private
+    def new_command
+      Kamal::Commands::Lock.new(Kamal::Configuration.new(@config, version: "123"))
+    end
+end

test/commands/prune_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class CommandsPruneTest < ActiveSupport::TestCase
+  setup do
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ],
+      traefik: { "args" => { "accesslog.format" => "json", "metrics.prometheus.buckets" => "0.1,0.3,1.2,5.0" } }
+    }
+  end
+
+  test "dangling images" do
+    assert_equal \
+      "docker image prune --force --filter label=service=app --filter dangling=true",
+      new_command.dangling_images.join(" ")
+  end
+
+  test "tagged images" do
+    assert_equal \
+      "docker image ls --filter label=service=app --format '{{.ID}} {{.Repository}}:{{.Tag}}' | grep -v -w \"$(docker container ls -a --format '{{.Image}}\\|' --filter label=service=app | tr -d '\\n')dhh/app:latest\\|dhh/app:<none>\" | while read image tag; do docker rmi $tag; done",
+      new_command.tagged_images.join(" ")
+  end
+
+  test "containers" do
+    assert_equal \
+      "docker ps -q -a --filter label=service=app --filter status=created --filter status=exited --filter status=dead | tail -n +6 | while read container_id; do docker rm $container_id; done",
+      new_command.containers.join(" ")
+  end
+
+  private
+    def new_command
+      Kamal::Commands::Prune.new(Kamal::Configuration.new(@config, version: "123"))
+    end
+end