dash 3.2.0 → 4.0.0

data/lib/{kamal → dash}/commands/app/images.rb

@@ -1,4 +1,4 @@
-module Kamal::Commands::App::Images
+module Dash::Commands::App::Images
   def list_images
     docker :image, :ls, config.repository
   end

data/lib/{kamal → dash}/commands/app/logging.rb

@@ -1,4 +1,4 @@
-module Kamal::Commands::App::Logging
+module Dash::Commands::App::Logging
   def logs(container_id: nil, timestamps: true, since: nil, lines: nil, grep: nil, grep_options: nil)
     pipe \
       container_id_command(container_id),

data/lib/{kamal → dash}/commands/app/proxy.rb

@@ -1,4 +1,4 @@
-module Kamal::Commands::App::Proxy
+module Dash::Commands::App::Proxy
   delegate :container_name, to: :"config.proxy_boot", prefix: :proxy
 
   def deploy(target:)
@@ -39,6 +39,6 @@ module Kamal::Commands::App::Proxy
 
   private
     def proxy_exec(*command)
-      docker :exec, proxy_container_name, "kamal-proxy", *command
+      docker :exec, proxy_container_name, "dash-proxy", *command
     end
 end

data/lib/{kamal → dash}/commands/app.rb

@@ -1,4 +1,4 @@
-class Kamal::Commands::App < Kamal::Commands::Base
+class Dash::Commands::App < Dash::Commands::Base
   include Assets, Containers, ErrorPages, Execution, Images, Logging, Proxy
 
   ACTIVE_DOCKER_STATUSES = [ :running, :restarting ]
@@ -18,7 +18,7 @@ class Kamal::Commands::App < Kamal::Commands::Base
       "--detach",
       "--restart", role.restart_policy,
       "--name", container_name,
-      "--network", "kamal",
+      "--network", "dash",
       *([ "--hostname", hostname ] if hostname),
       "--env", "KAMAL_CONTAINER_NAME=\"#{container_name}\"",
       "--env", "KAMAL_VERSION=\"#{config.version}\"",

data/lib/{kamal → dash}/commands/auditor.rb

@@ -1,6 +1,6 @@
-class Kamal::Commands::Auditor < Kamal::Commands::Base
+class Dash::Commands::Auditor < Dash::Commands::Base
   attr_reader :details
-  delegate :escape_shell_value, to: Kamal::Utils
+  delegate :escape_shell_value, to: Dash::Utils
 
   def initialize(config, **details)
     super(config)
@@ -10,7 +10,7 @@ class Kamal::Commands::Auditor < Kamal::Commands::Base
   # Runs remotely
   def record(line, **details)
     combine \
-      make_run_directory,
+      ensure_run_directory,
       append([ :echo, escape_shell_value(audit_line(line, **details)) ], audit_log_file)
   end
 
@@ -29,10 +29,6 @@ class Kamal::Commands::Auditor < Kamal::Commands::Base
       tags(**self.details, **details)
     end
 
-    def make_run_directory
-      [ :mkdir, "-p", config.run_directory ]
-    end
-
     def audit_line(line, **details)
       "#{audit_tags(**details).except(:version, :service_version, :service)} #{line}"
     end

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

@@ -1,6 +1,6 @@
-module Kamal::Commands
+module Dash::Commands
   class Base
-    delegate :sensitive, :argumentize, to: Kamal::Utils
+    delegate :sensitive, :argumentize, to: Dash::Utils
 
     # Prefixed onto the docker state when the container declares no healthcheck at all, so
     # "nothing is probing this container" stays distinguishable from "the probe passed" —
@@ -32,6 +32,32 @@ module Kamal::Commands
       [ :mkdir, "-p", path ]
     end
 
+    # Creates the run directory, renaming a pre-3b `.kamal` into place first.
+    #
+    # Lives on Base because two unlocked paths reach the run directory before
+    # Dash::Cli::Base#ensure_run_directory does — the auditor records "Pulled
+    # image" during `build:pull`, and every `mkdir -p .dash/...` underneath it
+    # creates the parent. If any of them made the directory with a bare mkdir,
+    # `.dash` would exist by the time the guard ran and the legacy tree would be
+    # stranded. Everything that can be first must run the same command.
+    #
+    # The migration is safe to repeat on every command:
+    #
+    # - Idempotent - once `.dash` exists the second guard is false forever.
+    # - Atomic - the two are siblings in the SSH user's home, so this is a
+    #   rename within one filesystem, never a copy.
+    # - Invisible to running containers - a bind mount resolves to an inode,
+    #   so the live proxy keeps serving from the renamed directory and only
+    #   picks up the new path when it is next recreated.
+    #
+    # `test` leads deliberately: SSHKit's command map passes `if`/`test`/`time`/
+    # `exec` through untouched and prefixes everything else with `/usr/bin/env`.
+    # The trailing `|| true` keeps the exit status zero when there is nothing to
+    # migrate, since callers execute this with raise_on_non_zero_exit on.
+    def ensure_run_directory
+      combine migrate_legacy_run_directory, make_directory(config.run_directory)
+    end
+
     def remove_directory(path)
       [ :rm, "-r", path ]
     end
@@ -51,6 +77,16 @@ module Kamal::Commands
     end
 
     private
+      def migrate_legacy_run_directory
+        any \
+          combine(
+            [ :test, "-d", Dash::Configuration::LEGACY_RUN_DIRECTORY ],
+            [ :test, "!", "-e", config.run_directory ],
+            [ :mv, Dash::Configuration::LEGACY_RUN_DIRECTORY, config.run_directory ]
+          ),
+          [ :true ]
+      end
+
       def combine(*commands, by: "&&")
         commands
           .compact
@@ -107,7 +143,7 @@ module Kamal::Commands
       end
 
       def tags(**details)
-        Kamal::Tags.from_config(config, **details)
+        Dash::Tags.from_config(config, **details)
       end
 
       def ssh_config_args

data/lib/{kamal → dash}/commands/builder/base.rb

@@ -1,9 +1,9 @@
-class Kamal::Commands::Builder::Base < Kamal::Commands::Base
+class Dash::Commands::Builder::Base < Dash::Commands::Base
   class BuilderError < StandardError; end
 
   ENDPOINT_DOCKER_HOST_INSPECT = "'{{.Endpoints.docker.Host}}'"
 
-  delegate :argumentize, to: Kamal::Utils
+  delegate :argumentize, to: Dash::Utils
   delegate \
     :args, :secrets, :dockerfile, :target, :arches, :local_arches, :remote_arches, :remote,
     :pack?, :pack_builder, :pack_buildpacks,

data/lib/{kamal → dash}/commands/builder/clone.rb

@@ -1,4 +1,4 @@
-module Kamal::Commands::Builder::Clone
+module Dash::Commands::Builder::Clone
   def clone
     git :clone, escaped_root, "--recurse-submodules", path: config.builder.clone_directory.shellescape
   end
@@ -7,7 +7,7 @@ module Kamal::Commands::Builder::Clone
     [
       git(:remote, "set-url", :origin, escaped_root, path: escaped_build_directory),
       git(:fetch, :origin, path: escaped_build_directory),
-      git(:reset, "--hard", Kamal::Git.revision, path: escaped_build_directory),
+      git(:reset, "--hard", Dash::Git.revision, path: escaped_build_directory),
       git(:clean, "-fdx", path: escaped_build_directory),
       git(:submodule, :update, "--init", path: escaped_build_directory),
       git(:gc, "--auto", "--quiet", path: escaped_build_directory)
@@ -23,7 +23,7 @@ module Kamal::Commands::Builder::Clone
   end
 
   def escaped_root
-    Kamal::Git.root.shellescape
+    Dash::Git.root.shellescape
   end
 
   def escaped_build_directory

data/lib/{kamal → dash}/commands/builder/cloud.rb

@@ -1,4 +1,4 @@
-class Kamal::Commands::Builder::Cloud < Kamal::Commands::Builder::Base
+class Dash::Commands::Builder::Cloud < Dash::Commands::Builder::Base
   # Expects `driver` to be of format "cloud docker-org-name/builder-name"
 
   def create

data/lib/{kamal → dash}/commands/builder/hybrid.rb

@@ -1,4 +1,4 @@
-class Kamal::Commands::Builder::Hybrid < Kamal::Commands::Builder::Remote
+class Dash::Commands::Builder::Hybrid < Dash::Commands::Builder::Remote
   def create
     combine \
       create_local_buildx,

data/lib/{kamal → dash}/commands/builder/local.rb

@@ -1,4 +1,4 @@
-class Kamal::Commands::Builder::Local < Kamal::Commands::Builder::Base
+class Dash::Commands::Builder::Local < Dash::Commands::Builder::Base
   def create
     return if docker_driver?
 

data/lib/{kamal → dash}/commands/builder/pack.rb

@@ -1,4 +1,4 @@
-class Kamal::Commands::Builder::Pack < Kamal::Commands::Builder::Base
+class Dash::Commands::Builder::Pack < Dash::Commands::Builder::Base
   def push(export_action = "registry", tag_as_dirty: false, no_cache: false)
     combine \
       build(tag_as_dirty: tag_as_dirty, no_cache: no_cache),

data/lib/{kamal → dash}/commands/builder/remote.rb

@@ -1,4 +1,4 @@
-class Kamal::Commands::Builder::Remote < Kamal::Commands::Builder::Base
+class Dash::Commands::Builder::Remote < Dash::Commands::Builder::Base
   def create
     chain \
       create_remote_context,

data/lib/{kamal → dash}/commands/builder.rb

@@ -1,6 +1,6 @@
 require "active_support/core_ext/string/filters"
 
-class Kamal::Commands::Builder < Kamal::Commands::Base
+class Dash::Commands::Builder < Dash::Commands::Base
   delegate \
     :create, :remove, :dev, :push, :clean, :pull, :info, :inspect_builder,
     :validate_image, :first_mirror, :login_to_registry_locally?, :push_env,
@@ -13,7 +13,7 @@ class Kamal::Commands::Builder < Kamal::Commands::Base
   include Clone
 
   def name
-    target.class.to_s.remove("Kamal::Commands::Builder::").underscore.inquiry
+    target.class.to_s.remove("Dash::Commands::Builder::").underscore.inquiry
   end
 
   def target
@@ -33,22 +33,22 @@ class Kamal::Commands::Builder < Kamal::Commands::Base
   end
 
   def remote
-    @remote ||= Kamal::Commands::Builder::Remote.new(config)
+    @remote ||= Dash::Commands::Builder::Remote.new(config)
   end
 
   def local
-    @local ||= Kamal::Commands::Builder::Local.new(config)
+    @local ||= Dash::Commands::Builder::Local.new(config)
   end
 
   def hybrid
-    @hybrid ||= Kamal::Commands::Builder::Hybrid.new(config)
+    @hybrid ||= Dash::Commands::Builder::Hybrid.new(config)
   end
 
   def pack
-    @pack ||= Kamal::Commands::Builder::Pack.new(config)
+    @pack ||= Dash::Commands::Builder::Pack.new(config)
   end
 
   def cloud
-    @cloud ||= Kamal::Commands::Builder::Cloud.new(config)
+    @cloud ||= Dash::Commands::Builder::Cloud.new(config)
   end
 end

data/lib/dash/commands/docker.rb

@@ -0,0 +1,89 @@
+class Dash::Commands::Docker < Dash::Commands::Base
+  # Install Docker using the https://github.com/docker/docker-install convenience script.
+  def install
+    pipe get_docker, :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 ] || sudo -nl usermod >/dev/null' ]
+  end
+
+  def root?
+    [ '[ "${EUID:-$(id -u)}" -eq 0 ]' ]
+  end
+
+  def in_docker_group?
+    [ 'id -nG "${USER:-$(id -un)}" | grep -qw docker' ]
+  end
+
+  def add_to_docker_group
+    [ 'sudo -n usermod -aG docker "${USER:-$(id -un)}"' ]
+  end
+
+  def refresh_session
+    [ "kill -HUP $PPID" ]
+  end
+
+  # Checks that an image's manifest can be fetched from its registry. Fails if it's missing or we're unauthorized.
+  def manifest_available?(image)
+    docker :manifest, :inspect, image
+  end
+
+  def create_network
+    docker :network, :create, Dash::Configuration::Proxy::NETWORK
+  end
+
+  # Stage 3c: docker cannot rename a network, so `dash` is created alongside
+  # `kamal` and everything still on the old one is joined to the new one.
+  #
+  # App containers would be replaced by the next deploy anyway; accessories are
+  # not, and that is the whole point — without this a renamed proxy cannot
+  # reach `db` or `redis`. Connecting a container that is already attached
+  # fails, so each connect tolerates its own failure rather than aborting the
+  # sweep. The old network is never removed; that is documented manual cleanup
+  # and stage 3d's code change.
+  def connect_legacy_network_containers
+    any \
+      combine(
+        legacy_network_exists,
+        pipe(legacy_network_container_names, connect_each_to_network)
+      ),
+      [ :true ]
+  end
+
+  private
+    def legacy_network_exists
+      docker :network, :inspect, Dash::Configuration::Proxy::LEGACY_NETWORK, ">", "/dev/null", "2>&1"
+    end
+
+    def legacy_network_container_names
+      docker :network, :inspect, Dash::Configuration::Proxy::LEGACY_NETWORK,
+        "--format", "'{{range .Containers}}{{.Name}}{{\"\\n\"}}{{end}}'"
+    end
+
+    # Already-attached containers make `network connect` fail; tolerate each
+    # one's failure rather than letting it abort the sweep.
+    def connect_each_to_network
+      [ :xargs, "-r", "-I{}", "sh", "-c",
+        "'docker network connect #{Dash::Configuration::Proxy::NETWORK} {} 2>/dev/null || true'" ]
+    end
+
+    def get_docker
+      shell \
+        any \
+          [ :curl, "-fsSL", "https://get.docker.com" ],
+          [ :wget, "-O -", "https://get.docker.com" ],
+          [ :echo, "\"exit 1\"" ]
+    end
+end

data/lib/{kamal → dash}/commands/hook.rb

@@ -1,4 +1,4 @@
-class Kamal::Commands::Hook < Kamal::Commands::Base
+class Dash::Commands::Hook < Dash::Commands::Base
   def run(hook)
     [ hook_file(hook) ]
   end

data/lib/{kamal → dash}/commands/loadbalancer.rb

@@ -1,7 +1,7 @@
-class Kamal::Commands::Loadbalancer < Kamal::Commands::Base
-  include Kamal::Commands::Proxy::CertTransfer
+class Dash::Commands::Loadbalancer < Dash::Commands::Base
+  include Dash::Commands::Proxy::CertTransfer
 
-  delegate :argumentize, :optionize, to: Kamal::Utils
+  delegate :argumentize, :optionize, to: Dash::Utils
 
   attr_reader :loadbalancer_config
 
@@ -14,11 +14,11 @@ class Kamal::Commands::Loadbalancer < Kamal::Commands::Base
     docker \
       :run,
       "--name", container_name,
-      "--network", "kamal",
+      "--network", "dash",
       "--detach",
       "--restart", "unless-stopped",
       "--label", label,
-      "--label", "#{Kamal::Commands::Proxy::CONFIG_DIGEST_LABEL}=#{loadbalancer_config.run_config_digest}",
+      "--label", "#{Dash::Commands::Proxy::CONFIG_DIGEST_LABEL}=#{loadbalancer_config.run_config_digest}",
       *config_volume,
       *run_args,
       *loadbalancer_config.run.image,
@@ -38,31 +38,32 @@ class Kamal::Commands::Loadbalancer < Kamal::Commands::Base
   end
 
   def deploy(targets: [])
-    docker :exec, container_name, "kamal-proxy", "deploy", loadbalancer_config.config.service,
+    docker :exec, container_name, "dash-proxy", "deploy", loadbalancer_config.config.service,
       *loadbalancer_config.deploy_command_args(targets: targets)
   end
 
-  def domains(subcommand)
-    docker :exec, container_name, "kamal-proxy", "domains", subcommand
+  # `retry` takes a host, or --all; the rest take no arguments.
+  def domains(subcommand, *args)
+    docker :exec, container_name, "dash-proxy", "domains", subcommand, *args
   end
 
   def list(json: false)
-    docker :exec, container_name, "kamal-proxy", :list, *("--json" if json)
+    docker :exec, container_name, "dash-proxy", :list, *("--json" if json)
   end
 
   # Cache policy is edge-only under load balancing (see the layering contract),
   # so the cache admin surface lives here - registered under the bare service
   # name, unlike the per-role services on the proxy hosts.
   def cache_stats(count: false, json: false)
-    docker :exec, container_name, "kamal-proxy", :cache, :stats, *optionize({ count: count || nil, json: json || nil }.compact)
+    docker :exec, container_name, "dash-proxy", :cache, :stats, *optionize({ count: count || nil, json: json || nil }.compact)
   end
 
   def cache_purge(service, path_prefix: nil)
-    docker :exec, container_name, "kamal-proxy", :cache, :purge, service, *optionize({ "path-prefix": path_prefix }.compact)
+    docker :exec, container_name, "dash-proxy", :cache, :purge, service, *optionize({ "path-prefix": path_prefix }.compact)
   end
 
   def config_digest
-    docker :inspect, container_name, "--format", "'{{ index .Config.Labels \"#{Kamal::Commands::Proxy::CONFIG_DIGEST_LABEL}\" }}'"
+    docker :inspect, container_name, "--format", Dash::Commands::Proxy::CONFIG_DIGEST_FORMAT
   end
 
   def container_id(only_running: false)
@@ -93,16 +94,24 @@ class Kamal::Commands::Loadbalancer < Kamal::Commands::Base
   end
 
   # Prune by the label the container was actually created with - on a shared
-  # proxy host that is the kamal-proxy title, and pruning by the loadbalancer
-  # title would leave the container behind for `run` to collide with.
+  # proxy host that is the dash-proxy title, and pruning by the loadbalancer
+  # title would leave the container behind for `run` to collide with. Both the
+  # current and the pre-rename title are pruned, so a container created before
+  # the rename is not left behind to collide either.
   def remove_container
-    docker :container, :prune, "--force", "--filter", "label=#{label}"
+    combine \
+      prune_containers_titled(image_title),
+      prune_containers_titled(legacy_image_title)
   end
 
   # Image label filters match labels baked into the image, and the load balancer
-  # runs the kamal-proxy image whichever host it sits on.
+  # runs the dash-proxy image whichever host it sits on. Both titles are matched
+  # so a host still carrying a pre-rename image is cleaned up too; Docker ANDs
+  # multiple `--filter label=` values, so that is two commands.
   def remove_image
-    docker :image, :prune, "--all", "--force", "--filter", "label=org.opencontainers.image.title=kamal-proxy"
+    combine \
+      prune_images_titled(Dash::Configuration::Proxy::IMAGE_TITLE),
+      prune_images_titled(Dash::Configuration::Proxy::LEGACY_IMAGE_TITLE)
   end
 
   def ensure_directory
@@ -110,7 +119,7 @@ class Kamal::Commands::Loadbalancer < Kamal::Commands::Base
   end
 
   # Where the proxy secrets env file lands (see Proxy::Run#secrets_path) -
-  # the same .kamal/proxy directory the per-app proxy hosts use.
+  # the same .dash/proxy directory the per-app proxy hosts use.
   def ensure_proxy_directory
     make_directory loadbalancer_config.run.host_directory
   end
@@ -152,28 +161,50 @@ class Kamal::Commands::Loadbalancer < Kamal::Commands::Base
       loadbalancer_config.on_proxy_host?
     end
 
+    # The full `key=value` the container is created with, so `--label #{label}`
+    # stays correct. The prune helpers take a bare title instead.
     def label
+      "org.opencontainers.image.title=#{image_title}"
+    end
+
+    def image_title
       if on_proxy_host?
-        "org.opencontainers.image.title=kamal-proxy"
+        Dash::Configuration::Proxy::IMAGE_TITLE
       else
-        "org.opencontainers.image.title=kamal-loadbalancer"
+        Dash::Configuration::Proxy::LOADBALANCER_IMAGE_TITLE
       end
     end
 
-    # kamal-proxy keeps its state under /home/kamal-proxy/.config/kamal-proxy
+    def legacy_image_title
+      if on_proxy_host?
+        Dash::Configuration::Proxy::LEGACY_IMAGE_TITLE
+      else
+        Dash::Configuration::Proxy::LEGACY_LOADBALANCER_IMAGE_TITLE
+      end
+    end
+
+    def prune_containers_titled(title)
+      docker :container, :prune, "--force", "--filter", "label=org.opencontainers.image.title=#{title}"
+    end
+
+    def prune_images_titled(title)
+      docker :image, :prune, "--all", "--force", "--filter", "label=org.opencontainers.image.title=#{title}"
+    end
+
+    # dash-proxy keeps its state under /home/dash-proxy/.config/dash-proxy
     # whichever host it runs on - only the volume name differs, so a dedicated
     # load balancer and a shared proxy host never fight over the same volume.
     # (The apps-config mount comes with run_args, via the proxy's run surface.)
     def config_volume
       if on_proxy_host?
-        [ "--volume", "kamal-proxy-config:/home/kamal-proxy/.config/kamal-proxy" ]
+        [ "--volume", "dash-proxy-config:/home/dash-proxy/.config/dash-proxy" ]
       else
-        [ "--volume", "kamal-loadbalancer-config:/home/kamal-proxy/.config/kamal-proxy" ]
+        [ "--volume", "dash-loadbalancer-config:/home/dash-proxy/.config/dash-proxy" ]
       end
     end
 
     # The certificate store lives in whichever config volume this loadbalancer
-    # actually mounts — the shared kamal-proxy one on a proxy host.
+    # actually mounts — the shared dash-proxy one on a proxy host.
     def cert_store_volume_args
       config_volume
     end

data/lib/{kamal → dash}/commands/lock.rb

@@ -2,9 +2,9 @@ require "active_support/duration"
 require "time"
 require "base64"
 
-class Kamal::Commands::Lock < Kamal::Commands::Base
+class Dash::Commands::Lock < Dash::Commands::Base
   # The deploy lock is scoped to service+destination, so two destinations can
-  # deploy at once. Server-scoped resources — above all the single kamal-proxy
+  # deploy at once. Server-scoped resources — above all the single dash-proxy
   # container a host runs for every destination on it — need a lock that every
   # destination contends for, hence :server.
   SCOPES = %i[ destination server ].freeze
@@ -85,7 +85,7 @@ class Kamal::Commands::Lock < Kamal::Commands::Base
     end
 
     def locked_by
-      Kamal::Git.user_name
+      Dash::Git.user_name
     rescue Errno::ENOENT
       "Unknown"
     end

data/lib/{kamal → dash}/commands/proxy/cert_transfer.rb

@@ -10,7 +10,7 @@
 # The including class provides `container_name`, `cert_store_volume_args` (the
 # config volume mount) and `one_off_image` (the image tokens for a one-off
 # container).
-module Kamal::Commands::Proxy::CertTransfer
+module Dash::Commands::Proxy::CertTransfer
   CERT_ARCHIVE_FILENAME = "certs-export.tar.gz"
   CERT_IMPORT_STAGING_FILENAME = "certs-import"
   CONTAINER_IMPORT_PATH = "/tmp/kamal-cert-import"
@@ -18,20 +18,20 @@ module Kamal::Commands::Proxy::CertTransfer
   # Through the RPC socket of the running container, under the proxy's own
   # certificate write lock, so a backup taken mid-renewal is never torn.
   def export_certs
-    docker :exec, container_name, "kamal-proxy", :export, :certs, certs_archive_container_path
+    docker :exec, container_name, "dash-proxy", :export, :certs, certs_archive_container_path
   end
 
   # Reads the data directory offline over the config volume — only safe when
-  # the container is stopped, which Kamal::Cli::Proxy guarantees.
+  # the container is stopped, which Dash::Cli::Proxy guarantees.
   def export_certs_offline
     docker :run, "--rm",
       *cert_store_volume_args,
       *config.proxy_boot.apps_volume.docker_args,
       *one_off_image,
-      "kamal-proxy", :export, :certs, certs_archive_container_path
+      "dash-proxy", :export, :certs, certs_archive_container_path
   end
 
-  # Offline by design (kamal-proxy import has no RPC path): the one-off
+  # Offline by design (dash-proxy import has no RPC path): the one-off
   # container mounts the config volume — creating it when no proxy has booted
   # yet, which is the Traefik-migration case — and the staged source streams
   # through stdin.
@@ -42,7 +42,7 @@ module Kamal::Commands::Proxy::CertTransfer
     # run whatever follows on the target host.
     import_command = shell [
       "cat > #{CONTAINER_IMPORT_PATH} &&",
-      "kamal-proxy import certs",
+      "dash-proxy import certs",
       *optionize({ source_flag => CONTAINER_IMPORT_PATH, resolver: resolver, force: force || nil, verify: verify || nil }.compact, with: "=")
     ]