kuby-core 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06ed279a1b0ecaac0daed1b868610bac67e6564611360de4cd841a24827438e2
-  data.tar.gz: f8616a5b0ab87c4fb71afa3afba0e001760b3c0855b7670b976013de3c1db5d6
+  metadata.gz: c537d5778b44ceab6bbd75ae91b2c8569bdba7356c25112c172ce10533a5b073
+  data.tar.gz: c8fda1880975e51a5e398ccb5e42474ead68e7a179ea403ded3b15ee615dc4f1
 SHA512:
-  metadata.gz: d75bf991f55a97798152449606740b2d94c9a012ad7c17ea0b9b940c9ca9b3aad0e31baa4635ffeeec584144492d967054cdbfffa386c05c7427f1e90ac58e8f
-  data.tar.gz: 73b7718181d0e43ab1382c70a4a22da1835da30c887c2f42bc67bcce15d811aa0efab93df3a5fd6d28e2b2ce6d6dc3a73154a4cacdadcfeb9641ca0b2ba5604c
+  metadata.gz: ea78f96fa54b86a8917e252af444e92465b43e9017c52e25e9e643df50095a31a15462ba48f8db1f94063aff414ce9d2eb2a9e3617e2c9581823d339c810a0af
+  data.tar.gz: b791c2e2190e8c16a52b1039f565f9e6f04d55bc47395d0133581503beb882019139199da14efecf2d488a26e6229e7beaf649375c5067df69db6c0c7787fcf2

data/CHANGELOG.md

@@ -1,3 +1,47 @@
+## 0.18.0
+* Add the ability to specify your app's root directory.
+  - Call `app_root <path>` inside the `docker` section of your Kuby config file.
+  - Necessary for use-cases like apps living inside gem repos, etc.
+* Add `:app_phase` to set of Docker build phases.
+  - Allows easily setting environment variables.
+  - Sets the working directory to the app root if the app's root directory has been set via the `app_root` feature described above.
+* Upgrade to Nginx ingress controller v1.1.1.
+  - Necessary to support Kind, the local Kubernetes cluster tool (see the kuby-kind gem).
+* Run `bundle lock` before installing gem dependencies.
+* Fix bug causing errors when certain container registries return a 401 if the repo doesn't exist yet.
+  - I'm looking at you, Azure.
+* Don't fail to deploy if the app doesn't use Active Record.
+* Fix git merge issue causing no output when running `kuby dockerfiles`.
+* Upgrade integration tests to Kubernetes 1.23.
+  - This upgrade is incompatible with the version of KubeDB we're currently using.
+  - KubeDB has been replaced with the CockroachDB operator. Kuby will no longer support KubeDB after this release.
+* Add ability to deploy resources into more than one namespace.
+* Remove support for MySQL and Postgres in favor of CockroachDB.
+  - KubeDB has moved to an incompatible licensing model and Kuby can no longer use it.
+  - CockroachDB is now the only managed database offering (aside from SQLite) for the following reasons:
+    - CRDB is cloud-native, i.e. is designed to be run on cloud platforms like Kubernetes.
+    - CRDB can be easily upgraded in-place while both MySQL and Postgres demand a much more manual, error-prone upgrade process that proved very difficult to automate.
+    - CRDB is Postgres wire-compatible, meaning those who use Postgres (and I believe that accounts for the majority of Rails devs) will hardly be impacted by this change at all. While CRDB is not feature-by-feature compatible with Postgres, the differences are unlikely to be important to the average Rails app.
+* Use SSL certificates instead of usernames and passwords for database authentication.
+  - This is the preferred way to communicate with instances of CockroachDB (also supported by Postgres).
+  - Kuby uses cert-manager to establish a custom PKI for database interactions.
+  - The Rails generator now entirely omits the database configuration section, making config simpler.
+* Avoid failing on first deploy.
+  - Previous versions of Kuby did not wait for the database to spin up before attempting to start the Rails app, which resulted in what appeared to be a failed deploy. Kubernetes would eventually sort everything out, but it made for a less than ideal developer experience.
+  - The `create_unless_exists` rake task has been superceded by the `bootstrap` rake task, which is run in an init container whenever the app boots. It is responsible for ensuring the database server is reachable and creating any users defined in the Kuby config.
+* Add the ability for plugins to define their own set of rake tasks.
+  - These are runnable via the CLI.
+* Add the ability for plugins to define a `#remove` routine, which is meant to do the opposite of whatever `#setup` does.
+  - It is now also possible to run a plugin's remove routine from the CLI.
+* Add the ability for plugins to depend on things like Kubernetes and Helm.
+  - Uses semantic versioning and compares required versions to current versions.
+* Avoid using the `which` command to find executables on the current PATH.
+  - `which` has been deprecated in at least one Linux distro (Debian), perhaps others.
+  - Use `Kuby::Utils.which` instead.
+* Support Rails 7.
+  - Don't run `yarn install` if there's no package.json.
+* Automatically cache Docker builds from the latest image, should it exist.
+
 ## 0.17.1
 * Allow storage class to be customized when using the built-in bare metal provider.
 * Fix a bug where the assets image would be built using the previous app image instead of the current one.

data/Gemfile

@@ -5,8 +5,12 @@ gemspec
 group :development, :test do
   gem 'pry-byebug'
   gem 'rake'
-  # lock to a specific version to prevent breaking CI when new versions come out
-  gem 'sorbet', '= 0.5.6433'
+
+  gem 'curdle', '~> 1.2'
+  gem 'parlour', github: 'camertron/parlour', branch: 'initialize_void' # '~> 7.0'
+  gem 'tapioca', '~> 0.7'
+  gem 'sorbet-runtime', '= 0.5.9897'
+  gem 'sorbet-static', '= 0.5.9897'
 end
 
 group :test do

data/Rakefile

@@ -1,10 +1,12 @@
 require 'bundler'
 require 'rspec/core/rake_task'
-require 'rubygems/package_task'
+require 'curdle'
 
-require 'kuby'
+Curdle::Tasks.install
 
-Bundler::GemHelper.install_tasks
+require 'pry-byebug'
+require 'sorbet-runtime'
+require 'kuby'
 
 task default: :spec
 

data/bin/tapioca

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'tapioca' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("tapioca", "tapioca")

data/kuby-core.gemspec

@@ -13,24 +13,22 @@ Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.add_dependency 'colorize', '~> 0.8'
-  s.add_dependency 'docker-remote', '~> 0.6'
-  s.add_dependency 'gli', '~> 2.0'
+  s.add_dependency 'docker-remote', '~> 0.8'
+  s.add_dependency 'gli', '~> 2.21'
   s.add_dependency 'helm-cli', '~> 0.3'
-  # See: https://github.com/Shopify/krane/pull/720
-  # See: https://github.com/Shopify/krane/blob/master/CHANGELOG.md#114
-  s.add_dependency 'krane', '>= 1.1.4', '< 2.0'
-  s.add_dependency 'kuby-cert-manager', '>= 0.3'
-  s.add_dependency 'kube-dsl', '~> 0.4'
-  s.add_dependency 'kuby-kube-db', '>= 0.6'
-  s.add_dependency 'kubernetes-cli', '~> 0.3'
+  s.add_dependency 'krane', '~> 2.0'
+  s.add_dependency 'kuby-cert-manager', '~> 0.4'
+  s.add_dependency 'kuby-crdb', '~> 0.2'
+  s.add_dependency 'kube-dsl', '~> 0.7'
+  s.add_dependency 'kubernetes-cli', '~> 0.4'
   s.add_dependency 'railties', '>= 5.1'
   s.add_dependency 'rouge', '~> 3.0'
-  s.add_dependency 'sorbet-runtime-stub', '~> 0.2'
+  s.add_dependency 'rake'
 
   s.add_development_dependency 'rspec'
 
   s.require_path = 'lib'
   s.executables << 'kuby'
 
-  s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kuby-core.gemspec']
+  s.files = Dir['{bin,lib,rbi,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kuby-core.gemspec']
 end

data/lib/kuby/basic_logger.rb

@@ -5,25 +5,25 @@ require 'colorized_string'
 
 module Kuby
   class BasicLogger < Logger
-    extend T::Sig
+    # extend T::Sig
 
-    sig {
-      override.params(
-        logdev: T.any(String, IO, StringIO, NilClass),
-        shift_age: Integer,
-        shift_size: Integer,
-        level: Integer,
-        progname: T.nilable(String),
-        formatter: T.nilable(FormatterProcType),
-        datetime_format: T.nilable(String),
-        shift_period_suffix: T.nilable(String)
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   override.params(
+    #     logdev: T.any(String, IO, StringIO, NilClass),
+    #     shift_age: Integer,
+    #     shift_size: Integer,
+    #     level: Integer,
+    #     progname: T.nilable(String),
+    #     formatter: T.nilable(FormatterProcType),
+    #     datetime_format: T.nilable(String),
+    #     shift_period_suffix: T.nilable(String)
+    #   ).void
+    # }
     def initialize(
         logdev, shift_age = 0, shift_size = 1048576, level: DEBUG,
         progname: nil, formatter: nil, datetime_format: nil,
         shift_period_suffix: '%Y%m%d')
-      @logdev = T.let(@logdev, T.nilable(Logger::LogDevice))
+      # @logdev = T.let(@logdev, T.nilable(Logger::LogDevice))
 
       super
 
@@ -32,12 +32,12 @@ module Kuby
       end
     end
 
-    sig {
-      override.params(
-        progname_or_msg: T.untyped,
-        block: T.nilable(T.proc.returns(T.untyped))
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   override.params(
+    #     progname_or_msg: T.untyped,
+    #     block: T.nilable(T.proc.returns(T.untyped))
+    #   ).void
+    # }
     def info(progname_or_msg = nil, &block)
       if block
         super(progname_or_msg) { ColorizedString[block.call].yellow }
@@ -46,12 +46,12 @@ module Kuby
       end
     end
 
-    sig {
-      override.params(
-        progname_or_msg: T.untyped,
-        block: T.nilable(T.proc.returns(T.untyped))
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   override.params(
+    #     progname_or_msg: T.untyped,
+    #     block: T.nilable(T.proc.returns(T.untyped))
+    #   ).void
+    # }
     def fatal(progname_or_msg = nil, &block)
       if block
         super(progname_or_msg) { ColorizedString[block.call].red }
@@ -61,13 +61,13 @@ module Kuby
     end
 
     # adhere to the "CLI" interface
-    sig {
-      params(
-        out: T.any(IO, StringIO),
-        err: T.any(IO, StringIO),
-        block: T.proc.void
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   params(
+    #     out: T.any(IO, StringIO),
+    #     err: T.any(IO, StringIO),
+    #     block: T.proc.void
+    #   ).void
+    # }
     def with_pipes(out = STDOUT, err = STDERR, &block)
       previous_logdev = @logdev&.dev || STDERR
       reopen(err)
@@ -76,7 +76,7 @@ module Kuby
       reopen(previous_logdev)
     end
 
-    sig { returns(T.nilable(Process::Status)) }
+    # T::Sig::WithoutRuntime.sig { returns(T.nilable(Process::Status)) }
     def last_status
       nil
     end

data/lib/kuby/cli_base.rb

@@ -5,39 +5,39 @@ require 'thread'
 
 module Kuby
   class CLIBase
-    extend T::Sig
+    # extend T::Sig
 
-    BeforeCallback = T.type_alias { T.proc.params(cmd: T::Array[String]).void }
-    AfterCallback = T.type_alias do
-      T.proc.params(cmd: T::Array[String], last_status: T.nilable(Process::Status)).void
-    end
+    # BeforeCallback = T.type_alias { T.proc.params(cmd: T::Array[String]).void }
+    # AfterCallback = T.type_alias do
+    #   T.proc.params(cmd: T::Array[String], last_status: T.nilable(Process::Status)).void
+    # end
 
-    sig { returns(T.nilable(Process::Status)) }
+    # T::Sig::WithoutRuntime.sig { returns(T.nilable(Process::Status)) }
     def last_status
       Thread.current[status_key]
     end
 
-    sig { params(block: BeforeCallback).void }
+    # T::Sig::WithoutRuntime.sig { params(block: BeforeCallback).void }
     def before_execute(&block)
-      @before_execute = T.let(@before_execute, T.nilable(T::Array[BeforeCallback]))
+      # @before_execute = T.let(@before_execute, T.nilable(T::Array[BeforeCallback]))
       @before_execute ||= []
       @before_execute << block
     end
 
-    sig { params(block: AfterCallback).void }
+    # T::Sig::WithoutRuntime.sig { params(block: AfterCallback).void }
     def after_execute(&block)
-      @after_execute = T.let(@after_execute, T.nilable(T::Array[AfterCallback]))
+      # @after_execute = T.let(@after_execute, T.nilable(T::Array[AfterCallback]))
       @after_execute ||= []
       @after_execute << block
     end
 
-    sig {
-      params(
-        out: T.any(IO, StringIO),
-        err: T.any(IO, StringIO),
-        block: T.proc.void
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   params(
+    #     out: T.any(IO, StringIO),
+    #     err: T.any(IO, StringIO),
+    #     block: T.proc.void
+    #   ).void
+    # }
     def with_pipes(out = STDOUT, err = STDERR, &block)
       previous_stdout = self.stdout
       previous_stderr = self.stderr
@@ -49,34 +49,34 @@ module Kuby
       self.stderr = previous_stderr
     end
 
-    sig { returns(T.nilable(T.any(IO, StringIO))) }
+    # T::Sig::WithoutRuntime.sig { returns(T.nilable(T.any(IO, StringIO))) }
     def stdout
       Thread.current[stdout_key] || STDOUT
     end
 
-    sig { params(new_stdout: T.nilable(T.any(IO, StringIO))).void }
+    # T::Sig::WithoutRuntime.sig { params(new_stdout: T.nilable(T.any(IO, StringIO))).void }
     def stdout=(new_stdout)
       Thread.current[stdout_key] = new_stdout
     end
 
-    sig { returns(T.nilable(T.any(IO, StringIO))) }
+    # T::Sig::WithoutRuntime.sig { returns(T.nilable(T.any(IO, StringIO))) }
     def stderr
       Thread.current[stderr_key] || STDERR
     end
 
-    sig { params(new_stderr: T.nilable(T.any(IO, StringIO))).void }
+    # T::Sig::WithoutRuntime.sig { params(new_stderr: T.nilable(T.any(IO, StringIO))).void }
     def stderr=(new_stderr)
       Thread.current[stderr_key] = new_stderr
     end
 
     private
 
-    sig {
-      params(
-        cmd: T::Array[String],
-        block: T.proc.params(stdin: IO).void
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   params(
+    #     cmd: T::Array[String],
+    #     block: T.proc.params(stdin: IO).void
+    #   ).void
+    # }
     def open3_w(cmd, &block)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -99,20 +99,20 @@ module Kuby
         yield(p_stdin)
 
         p_stdin.close
-        self.last_status = T.cast(wait_thread.value, Process::Status)
+        self.last_status = wait_thread.value
         run_after_callbacks(cmd)
         wait_thread.join
       end
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def execc(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
       exec(cmd_s)
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def systemm(cmd)
       if stdout == STDOUT && stderr == STDERR
         systemm_default(cmd)
@@ -121,7 +121,7 @@ module Kuby
       end
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def systemm_default(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -131,7 +131,7 @@ module Kuby
       end
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def systemm_open3(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -152,14 +152,14 @@ module Kuby
         end
 
         p_stdin.close
-        self.last_status = T.cast(wait_thread.value, Process::Status)
+        self.last_status = wait_thread.value
         run_after_callbacks(cmd)
         wait_thread.join
       end
     end
 
 
-    sig { params(cmd: T::Array[String]).returns(String) }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).returns(String) }
     def backticks(cmd)
       if stdout == STDOUT && stderr == STDERR
         backticks_default(cmd)
@@ -168,7 +168,7 @@ module Kuby
       end
     end
 
-    sig { params(cmd: T::Array[String]).returns(String) }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).returns(String) }
     def backticks_default(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -178,7 +178,7 @@ module Kuby
       end
     end
 
-    sig { params(cmd: T::Array[String]).returns(String) }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).returns(String) }
     def backticks_open3(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -200,7 +200,7 @@ module Kuby
         end
 
         p_stdin.close
-        self.last_status = T.cast(wait_thread.value, Process::Status)
+        self.last_status = wait_thread.value
         run_after_callbacks(cmd)
         wait_thread.join
       end
@@ -208,32 +208,32 @@ module Kuby
       result.string
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def run_before_callbacks(cmd)
       (@before_execute || []).each { |cb| cb.call(cmd) }
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def run_after_callbacks(cmd)
       (@after_execute || []).each { |cb| cb.call(cmd, last_status) }
     end
 
-    sig { params(status: Process::Status).void }
+    # T::Sig::WithoutRuntime.sig { params(status: Process::Status).void }
     def last_status=(status)
       Thread.current[status_key] = status
     end
 
-    sig { returns(Symbol) }
+    # T::Sig::WithoutRuntime.sig { returns(Symbol) }
     def status_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end
 
-    sig { returns(Symbol) }
+    # T::Sig::WithoutRuntime.sig { returns(Symbol) }
     def stdout_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end
 
-    sig { returns(Symbol) }
+    # T::Sig::WithoutRuntime.sig { returns(Symbol) }
     def stderr_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end

data/lib/kuby/commands.rb

@@ -3,9 +3,12 @@
 require 'kuby/version'
 require 'gli'
 
+# run the pre hook for the help command
+GLI::Commands::Help.skips_pre = false
+
 module Kuby
   class Commands
-    extend T::Sig
+    # extend T::Sig
     extend GLI::App
 
     # GLI doesn't have a wildcard option, so it's impossible to tell it to
@@ -19,12 +22,12 @@ module Kuby
     # avoid the usual series of cryptic alias_method calls (note that there
     # is no singleton class version of #prepend in the Ruby language).
     singleton_class.send(:prepend, Module.new do
-      extend T::Sig
+      # extend T::Sig
 
-      sig { params(args: T::Array[String]).void }
+      # T::Sig::WithoutRuntime.sig { params(args: T::Array[String]).void }
       def run(args)
         if idx = args.index('rails') || idx = args.index('rake')
-          @rails_options = T.let(@rails_options, T.nilable(T::Array[String]))
+          # @rails_options = T.let(@rails_options, T.nilable(T::Array[String]))
           @rails_options = args[(idx + 1)..-1]
           super(args[0..idx])
         else
@@ -34,11 +37,24 @@ module Kuby
       end
     end)
 
-    sig { returns(Kuby::Tasks) }
+    # T::Sig::WithoutRuntime.sig { returns(Kuby::Tasks) }
     def self.tasks
       Kuby::Tasks.new(Kuby.environment)
     end
 
+    # T::Sig::WithoutRuntime.sig {
+    #   params(
+    #     global_options: T::Hash[T.any(String, Symbol), T.any(String, Integer)]
+    #   ).void
+    # }
+    def self.load_kuby_config!(global_options)
+      return if @kuby_config_loaded
+
+      Kuby.env = global_options[:environment] if global_options[:environment]
+      Kuby.load!(global_options[:config])
+      @kuby_config_loaded = true
+    end
+
     program_desc 'Kuby command-line interface. Kuby is a convention '\
       'over configuration approach for running Rails apps in Kubernetes.'
 
@@ -54,9 +70,35 @@ module Kuby
     default_value './kuby.rb'
     flag [:c, :config]
 
+    command_missing do |command_name, global_options|
+      load_kuby_config!(global_options)
+      cmd = nil
+
+      # command_name is also the name of the plugin
+      if plugin_klass = Kuby.plugins.find(command_name)
+        if plugin_klass.respond_to?(:install_commands)
+          desc "Run commands for the #{command_name} plugin."
+          cmd = command(command_name) do |c|
+            # the plugin now defines its own commands on c
+            plugin_klass.install_commands(c)
+          end
+        end
+      end
+
+      cmd
+    end
+
     pre do |global_options, options, args|
-      Kuby.env = global_options[:environment] if global_options[:environment]
-      Kuby.load!(global_options[:config])
+      load_kuby_config!(global_options)
+
+      Kuby.plugins.each do |plugin_name, plugin_klass|
+        if plugin_klass.respond_to?(:commands) && !@commands[plugin_name]
+          desc "Run commands for the #{plugin_name} plugin."
+          command plugin_name.to_sym do |c|
+            plugin_klass.commands(c)
+          end
+        end
+      end
 
       # GLI will abort unless this block returns a truthy value
       true
@@ -68,7 +110,7 @@ module Kuby
       c.flag [:a, :arg], required: false, multiple: true
 
       c.desc 'When enabled, ignores missing build arguments.'
-      c.switch [:'ignore-missing-args'], required: false, default: false
+      c.switch [:'ignore-missing-args'], required: false, default_value: false
 
       c.desc 'Build only the images associated with the specified identifier(s). '\
              'Run `kuby images` for a list of all valid identifiers (note that '\
@@ -78,6 +120,9 @@ module Kuby
       c.desc 'The directory to use as the Docker build context.'
       c.flag [:c, :context], required: false
 
+      c.desc 'Pull the latest images from the registry and reuse any previously built layers.'
+      c.switch [:l, :'cache-from-latest'], required: false, default_value: true
+
       c.action do |global_options, options, docker_args|
         build_args = {}.tap do |build_args|
           (options[:arg] || []).each do |a|
@@ -91,7 +136,8 @@ module Kuby
           build_args, docker_args,
           only: options[:only],
           ignore_missing_args: options[:'ignore-missing-args'],
-          context: options[:context]
+          context: options[:context],
+          cache_from_latest: options[:'cache-from-latest']
         )
       end
     end
@@ -175,7 +221,7 @@ module Kuby
       c.desc 'Prefixes the kubectl command with the namespace associated with '\
              'the current environment. For example, if the Kuby env is "production", '\
              'this option will prefix the kubectl command with "-n myapp-production".'
-      c.switch [:N, :namespaced], default: false
+      c.switch [:N, :namespaced], default_value: false
       c.action do |global_options, options, args|
         if options[:namespaced]
           # sorry Demeter
@@ -187,6 +233,43 @@ module Kuby
       end
     end
 
+    desc 'Provides information about plugins.'
+    command :plugin do |rc|
+      rc.desc "Run a plugin's remove routine, i.e. uninstall it's resources from your cluster."
+      rc.command :remove do |c|
+        c.desc 'The plugin to remove. Run `kuby plugin list` for a list of valid plugin '\
+               'identifiers.'
+        c.flag [:p, :plugin], required: true
+        c.action do |global_options, options, args|
+          tasks.remove_plugin(options[:plugin])
+        end
+      end
+
+      rc.desc 'List plugins.'
+      rc.command :list do |c|
+        c.desc 'Show all available plugins, not just the ones in use.'
+        c.switch [:a, :all], default_value: false
+        c.action do |global_options, options, args|
+          tasks.list_plugins(all: options[:all])
+        end
+      end
+
+      rc.desc "Run one of a plugin's rake tasks. Omit task names to print all tasks."
+      rc.arg_name 'task_name', [:multiple, :optional]
+      rc.command :rake do |c|
+        c.action do |global_options, options, args|
+          # Args come through as @rails_options here because of the monkeypatch
+          # at the top of this file. Should revisit the patch at some point because
+          # I think GLI's arg concept can replace it.
+          if @rails_options.empty?
+            tasks.list_rake_tasks
+          else
+            tasks.run_rake_tasks(@rails_options)
+          end
+        end
+      end
+    end
+
     desc 'Runs commands, etc against the Kubernetes cluster.'
     command :remote do |rc|
       rc.desc 'Tails (i.e. continuously streams) the Rails log from your running application.'
@@ -206,7 +289,7 @@ module Kuby
       rc.desc 'Runs an arbitrary command inside a running Rails pod.'
       rc.command :exec do |c|
         c.action do |global_options, options, args|
-          tasks.remote_exec([*args, *T.unsafe(@rails_options)])
+          tasks.remote_exec([*args, *@rails_options])
         end
       end