mimas 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6cf8ecafcf4c63ec2a4f1325f280b0cc58e8f131846d3e7292ec350bbc191f57
+  data.tar.gz: cd14353d7c99bf62e9d18c450b91c360cfa662b908da8ed68cc0924fe2d86fd9
+SHA512:
+  metadata.gz: 7d62835764c60b57e811fdcecfc61c9df9e08c35f123d8ad871b6e2b2299432c18eb215e223a48e3be6bb8839c79d26f87e220caee5b83edb90b3f43166fb884
+  data.tar.gz: 1887653d2942eb2f734e60cf3be27aa1857ec0ef4615556fdbe2a88108627be5502ee757fa1816cef5c303bada25b3f542fbc351af58b22ef91898a62e2cb42c

data/.gitignore

@@ -0,0 +1,10 @@
+.bundle/
+.ruby-gemset
+*.gem
+
+.DS_Store
+
+/vendor
+*/tmp/*
+.vscode
+.yardoc

data/Gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake"
+
+group :test do
+  gem "debug"
+  gem "minitest"
+  gem "minitest-profile"
+  gem "minitest-reporters"
+end

data/Gemfile.lock

@@ -0,0 +1,106 @@
+PATH
+  remote: .
+  specs:
+    mimas (0.1.0)
+      bcrypt_pbkdf (~> 1.0)
+      dry-cli (~> 1.4)
+      ed25519 (~> 1.2)
+      logger (~> 1.7)
+      net-scp (~> 4.1)
+      net-ssh (~> 7.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.6.0)
+    bcrypt_pbkdf (1.1.2)
+    builder (3.3.0)
+    date (3.5.1)
+    debug (1.11.1)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    drb (2.2.3)
+    dry-cli (1.4.1)
+    ed25519 (1.4.0)
+    erb (6.0.4)
+    io-console (0.8.2)
+    irb (1.18.0)
+      pp (>= 0.6.0)
+      prism (>= 1.3.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    logger (1.7.0)
+    minitest (6.0.6)
+      drb (~> 2.0)
+      prism (~> 1.5)
+    minitest-profile (0.0.2)
+    minitest-reporters (1.8.0)
+      ansi
+      builder
+      minitest (>= 5.0, < 7)
+      ruby-progressbar
+    net-scp (4.1.0)
+      net-ssh (>= 2.6.5, < 8.0.0)
+    net-ssh (7.3.3)
+    pp (0.6.3)
+      prettyprint
+    prettyprint (0.2.0)
+    prism (1.9.0)
+    psych (5.4.0)
+      date
+      stringio
+    rake (13.4.2)
+    rdoc (7.2.0)
+      erb
+      psych (>= 4.0.0)
+      tsort
+    reline (0.6.3)
+      io-console (~> 0.5)
+    ruby-progressbar (1.13.0)
+    stringio (3.2.0)
+    tsort (0.2.0)
+
+PLATFORMS
+  arm64-darwin-23
+  ruby
+
+DEPENDENCIES
+  debug
+  mimas!
+  minitest
+  minitest-profile
+  minitest-reporters
+  rake
+
+CHECKSUMS
+  ansi (1.6.0) sha256=ac9ea0c0ea8d32fb4e271348e609963ac78882f34b73836c2a02b3622e666658
+  bcrypt_pbkdf (1.1.2) sha256=c2414c23ce66869b3eb9f643d6a3374d8322dfb5078125c82792304c10b94cf6
+  builder (3.3.0) sha256=497918d2f9dca528fdca4b88d84e4ef4387256d984b8154e9d5d3fe5a9c8835f
+  date (3.5.1) sha256=750d06384d7b9c15d562c76291407d89e368dda4d4fff957eb94962d325a0dc0
+  debug (1.11.1) sha256=2e0b0ac6119f2207a6f8ac7d4a73ca8eb4e440f64da0a3136c30343146e952b6
+  drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
+  dry-cli (1.4.1) sha256=b8015bb76c708aa8705a36faf694973e75eeeffca39b89c8e172dc6f66a7d874
+  ed25519 (1.4.0) sha256=16e97f5198689a154247169f3453ef4cfd3f7a47481fde0ae33206cdfdcac506
+  erb (6.0.4) sha256=38e3803694be357fe2bfe312487c74beaf9fb4e5beb3e22498952fe1645b95d9
+  io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc
+  irb (1.18.0) sha256=de9454a0703a54704b9811a5ef31a60c86949fbf4013fcf244fabc7c775248e3
+  logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
+  mimas (0.1.0)
+  minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1
+  minitest-profile (0.0.2) sha256=caf5306217b59ea2854d75ff6b312e2c139f2948f2b6a39486677b8317b7048e
+  minitest-reporters (1.8.0) sha256=8ce5280fb73ad3178ae525454df169b6f28c1b38b1d088ea91815d3a370ba384
+  net-scp (4.1.0) sha256=a99b0b92a1e5d360b0de4ffbf2dc0c91531502d3d4f56c28b0139a7c093d1a5d
+  net-ssh (7.3.3) sha256=831def58b2c51dcef66ec00d29397d4f210de89c19fe78f95873ca30f386e86a
+  pp (0.6.3) sha256=2951d514450b93ccfeb1df7d021cae0da16e0a7f95ee1e2273719669d0ab9df6
+  prettyprint (0.2.0) sha256=2bc9e15581a94742064a3cc8b0fb9d45aae3d03a1baa6ef80922627a0766f193
+  prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
+  psych (5.4.0) sha256=14f72d69a611af663d7d70e4a7b67d9eb1f3ae9f8d916b478961d5a0075ba5b7
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
+  rdoc (7.2.0) sha256=8650f76cd4009c3b54955eb5d7e3a075c60a57276766ebf36f9085e8c9f23192
+  reline (0.6.3) sha256=1198b04973565b36ec0f11542ab3f5cfeeec34823f4e54cebde90968092b1835
+  ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33
+  stringio (3.2.0) sha256=c37cb2e58b4ffbd33fe5cd948c05934af997b36e0b6ca6fdf43afa234cf222e1
+  tsort (0.2.0) sha256=9650a793f6859a43b6641671278f79cfead60ac714148aabe4e3f0060480089f
+
+BUNDLED WITH
+  4.0.6

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2026-present Ayush Newatia
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,346 @@
+# Mimas
+
+Mimas is a CLI tool to deploy Ruby apps and static sites to a single server. It provides an opinionated setup to serve sites with [Caddy](https://caddyserver.com) as a reverse proxy. 
+
+It can provision the server by applying security rules, create the users, configure log rotation, and install required software.  
+
+Multiple sites can be deployed to the same server. All deploys are zero-downtime. Mimas will create a new `systemd` service for each deploy, healthcheck it, before switching Caddy to the new service, and stopping and removing the old service.
+
+It doesn't do anything fancy under the hood, it's all the bash commands and scripts run by Ruby's `Net::SSH` utility.
+
+Mimas focuses on deploying apps, and doesn't build the app during deployment. Build your app locally or on your CI server before pushing it using Mimas.
+
+It has currently only been tested with Ubuntu 26.04. Mimas is still in early stages of development, so bugs are likely. Use with caution!
+
+## Getting Started
+
+Install Mimas and create a binstub:
+
+```shell
+$ bundle add mimas
+$ bundle binstub mimas
+```
+
+Run the `init` command to initialise a config file:
+
+```shell
+$ bin/mimas init
+```
+
+The command will ask you a number of questions about your setup and generate a config file for Mimas, as well as a [Caddyfile](https://caddyserver.com/docs/caddyfile).
+
+## Configuration
+
+Mimas requires a config file located at `deploy/mimas.rb`. It is defined using a DSL as demonstrated below:
+
+```ruby
+# A static site declaration. All shown fields are compulsory.
+# You may pass a name as `site :static do ... end`. When no name
+# is specified, it is set to `:default`.
+site do
+  domain      "<%= domain %>"
+  root_dir    "output"
+  glob        "**/*"
+end
+
+# A Ruby service declaration. For Ruby services, Use the `files` directive rather
+# than `root_dir` and `glob` as shown above. Mimas will create a TAR archive 
+# of the array returned by `files` and push that to the server.
+site :app do
+  domain  "<%= domain %>"
+  files do
+    `git ls-files -z`.split("\x0")
+      .reject { it.match(%r!(bin|mimas.rb|Caddyfile)!) }
+  end
+
+  # Optional path to conduct the healthcheck. Defaults to "/".
+  healthcheck_path "/up"
+
+  # Define the console command for your app here.
+  # You can then access the console by running `mimas console SERVER_NAME`
+  # console "bundle console"
+
+  # Assign environment variables for your Ruby process. Return a multi-line string.
+  # env do
+  #   <<~STRING
+  #   STRING
+  # end
+
+  # Your deploy script. Mimas automatically runs `bundle install` on 
+  # deploy if no deploy script is defined.
+  # Ensure you invoke `bundle install` if you provide your own script here.
+  # deploy do
+  #  <<~STRING
+  #  STRING
+  # end
+
+  # The services for your Ruby app. Each service will have its own
+  # `systemd` file.
+  services do
+    web do
+      start "bundle exec falcon host deploy/falcon.rb"
+    end
+  end
+end
+
+# A server declaration. You'll use the server's name as defined here
+# to deploy to it. `host` and `user` are compulsory, but additional
+# parameters for the SSH connection may be defined. They will be passed
+# as-is to `Net::SSH`: https://net-ssh.github.io/ssh/v1/chapter-2.html#s3.
+#
+# `Net::SSH` automatically reads the private key based on your SSH config. 
+# More info: https://binarysolo.blog/managing-ssh-key-pairs-for-server-access/
+server :production do
+  host  "<%= ip %>"
+  user  "deploy"
+# keys	 []
+end
+
+# You can define optionally hooks that run before and after code is pushed
+# to a server. You can use this to build your site locally before deployment.
+# Mimas doesn't build the site on deploy.
+# hooks do
+  # before_push do
+    # puts "This is a before push hook"
+  # end
+
+  # after_push do
+    # puts "This is an after push hook"
+  # end
+# end
+```
+
+You can define multiple sites in a single project as demonstrated above, you'll just need to `push` them independently. This approach can be useful if you're serving a static site and Ruby service from the same project.
+
+### Caddyfile
+
+Mimas also requires a Caddyfile specific to your website. It will automatically load it into the main Caddyfile which controls the entire server. `bin/mimas init` will create one for you. It is an ERB template which is processed on each deploy.
+
+```
+<%# An example Caddyfile.erb for a Ruby service %>
+<%# In addition to the below variables, the `site` and `server` %>
+<%# objects are also passed to it for additional configuration. %>
+<%# See the source code for usage details on those objects. %>
+
+<%= domain %> {
+  reverse_proxy {
+    to unix/<%= unix_socket %>
+
+    lb_try_duration 5s
+  }
+
+  log {
+    format console
+    output file <%= site_root %>/logs/caddy.log
+  }
+}
+```
+
+If you have multiple sites in your Mimas config, add the site name as an extension to the file name. For example, `Caddyfile.app.erb` will be used for a `site :app do ... end` in the Mimas config file.
+
+See the [Caddy docs](https://caddyserver.com/docs/caddyfile-tutorial) for details on the Caddyfile.
+
+## Deployment
+
+Once you have a valid Mimas config and a Caddyfile, you can provision your server:
+
+```shell
+# bin/mimas provision SERVER_NAME
+$ bin/mimas provision production
+```
+
+This will harden your server with security rules, install all required software including Ruby and Caddy, and create an `admin` and `deploy` user. 
+
+Node is not installed as Mimas doesn't build sites during deployment, and is designed specifically to serve Ruby apps.
+
+You can then push your website to the server:
+
+```shell
+# bin/mimas push SERVER_NAME [SITE_NAME]
+$ bin/mimas push production
+```
+
+If nothing goes wrong, and your DNS is configured to point to your server, your site should be live at your domain name!
+
+Mimas doesn't currently support rollbacks. Instead, I recommend you revert your code change and deploy again.
+
+## Mimas' Server Setup
+
+Mimas creates two users on your server: `admin` and `deploy`. Root access and password authentication is disabled. You'll need to use SSH keys to authenticate.
+
+The `admin` user has passwordless sudo access, and `deploy` does not. After the server is provisions, neither Mimas nor another automated tool should access the server using the `admin` account. All automated tasks should happen through the `deploy` account.
+
+Mimas will install Caddy and set up a root `Caddyfile` in `/home/deploy/http`. This will import the Caddyfiles for all individual sites. The `deploy` user is given specific sudo access to the commands to control the Caddy systemd service.
+
+Ruby versions are installed and managed using `ruby-install` and `chruby`. Ruby is built from source so installing a new version of Ruby on your server will take time.
+
+Each site is contained in a folder under `/home/deploy/http` named after its domain name. Here's what the file structure looks like:
+
+```
+/home/deploy/
+└── http
+    └── example.com
+        ├── Caddyfile
+        ├── current -> /home/deploy/http/example.com/releases/20260721194912
+        ├── logs
+        ├── mimas
+        └── releases
+            ├── 20260721183301
+            ├── 20260721193851
+            └── 20260721194912
+
+```
+
+On each deploy, a new folder is created under `releases` with the current timestamp. The `current` symlink will always point to the currently live release, and only the last 5 releases are retained. Older releases are deleted on deploy.
+
+The `mimas` folder contains a `mimas.env` file which is loaded for each service, and the Unix socket for the Ruby app server.
+
+On each deploy, Mimas will create a user systemd service in `~/.config/systemd/user/` and start it. If the healthcheck succeeds, it will point Caddy to the new release and reload it, then stop and delete the old service. This switch should be seamless, without downtime, as long as your application server supports graceful stops without dropping requests (both Puma and Falcon do).
+
+## Configuring The App Server
+
+Mimas requires your Ruby app to run on a Unix socket. The `MIMAS_UNIX_SOCKET` environment variable defines the path to the socket. Read that into your app server's config and bind it to that path. A new socket is created for each release to avoid clashes so both old and new services can run at the same time.
+
+Mimas will create configs for Puma or Falcon when you run `bin/mimas init`. Ensure you read the docs for your server to configure it for production use. The stock configs only contain the settings to bind it to the correct socket, and options like worker and thread count are not set.
+
+## How It Works
+
+During provisioning, Mimas will install Caddy using the `admin` account and create a systemd service for it which runs under the `deploy` user. The `deploy` user is given specific sudo access only to control this server.
+
+A global Caddyfile is created under `/home/deploy/http` which looks like:
+
+```
+import caddy.global
+import */Caddyfile
+```
+
+`caddy.global` contains settings that apply to all sites. The default configures it to run using HTTP/1.1 and HTTP/2 only. I found HTTP/3 causes weird connection issues in a browser between deploys.
+
+The second line automatically imports all site-specific Caddyfiles whenever Caddy is reloaded. This way, you can control your site's config independently.
+
+### Static Sites
+
+When a static site is deployed, Mimas will create an array of all the output files using the `root_dir` and `glob` directives in the config, and then create a TAR archive of the files. The archive is SCP'd to the server and extracted under a new `releases` folder named after the current timestamp. It will then update the `current` symlink to the latest release.
+
+Mimas will not build your site on the server. I believe the app server should not be used as a build server. Use a `before_push` hook to build your site locally or on a CI server.
+
+### Ruby Apps
+
+To deploy Ruby apps, Mimas will use the the `files` directive in the config to generate an array of files and create a TAR archive. It will then read the `.ruby-version` file, or if one doesn't exist, the `RUBY_VERSION` constant and verify whether that is installed on the server. If it isn't, the deploy will stop there. Install the required version with `bin/mimas install ruby VERSION SERVER_NAME`
+
+If the correct Ruby version is installed, deployment will continue as:
+
+1. SCP the archive to the server and extract it to a new `releases` folder named after the current timestamp.
+2. Create a new systemd service for the release and start it.
+3. Perform a healthcheck by making a `curl` request to the new release's Unix socket.
+4. Switch the `current` symlink to the new release and reload Caddy.
+5. Gracefully stop the old service and delete it.
+
+If deployment fails at any step, all newly released files and services will be cleaned up, and the existing version will continue to be served.
+
+## Logs
+
+Logs are written to the site's `logs/` folder. For systemd services, the `stdout` and `stderr` streams are both directed to a log file named after the service.
+
+Log rotation is automatically configured for this folder.
+
+## CLI
+
+Run the below command for all CLI options:
+
+```shell
+$ bin/mimas help
+```
+
+## Incomplete Functionality
+
+Mimas creates a `.env` file in the root directory of each site, which is read into the systemd service. There is no built-in way as yet to add content to this file. You'll need to SSH to your server, edit the file, and then re-deploy to pick up the changes. It lives across releases so you won't lose your changes on deploy.
+
+You can, however, define environment variables in your Mimas config using `env`. These are written to `<site_root>/mimas/mimas.env`.
+
+The purpose of the `.env` file is to store sensitive secrets like API keys that shouldn't be stored in the project. I'm still not completely sure of how to use the file as yet, so it exists but needs manual editing.
+
+## Plugins
+
+Mimas supports plugins that add or override commands, or add hooks. Common use cases would be to override the `init` command to generate a framework-specific config file, or to add hooks specific to your project or framework.
+
+Plugins must advertise that they are Mimas plugins in their gemspec:
+
+```ruby
+spec.metadata[:mimas_plugin] = "true"
+```
+
+Register your plugin as shown below:
+
+```ruby
+Mimas::Plugins.register(Mimas::Plugins::Bridgetown)
+```
+
+Here, `Mimas::Plugins::Bridgetown` must be an object (usually a module) that responds to the class methods `hooks` and `commands`
+
+The `hooks` method must return a `Mimas::Hooks` object:
+
+```ruby
+def hooks
+  hooks = Mimas::Hooks.new
+
+  hooks.before_push do
+    `bin/bt deploy`
+  end
+
+  hooks
+end
+```
+
+The `commands` method must return a Hash mapping the command name to the class containing it's implementation:
+
+```ruby
+def commands
+  { "init" => Commands::Init }
+end
+```
+
+The CLI is built on `dry-cli`, so your commands must be structured as per that framework.
+
+## Design Decisions
+
+In this section I'll briefly discuss why I made certain choices for Mimas.
+
+### CLI Framework
+
+I decided on `dry-cli` as it has an elegant API and allows for easy extensibility. Also, the scope is fairly small so it's easy to follow the source code.
+
+### Caddy
+
+Anyone who's ever used Nginx knows that hitting your head against the nearest wall is a more productive endeavour than dealing with an Nginx configuration. Caddy has fantastic docs and an easy to read configuration. Anything you could possibly need out of a web server and reverse proxy, Caddy has out of the box.
+
+I considered a setup where Falcon was internet-facing and used for SSL termination and SNI resolution to serve one or more apps. It can be started as `falcon virtual` for this very reason. However, Falcon is an app server and not a proxy or web server so it is limiting in what you can do. Also, it would make zero-downtime deploys when upgrading Ruby impossible, as it spawn child processes for each site from the main process. 
+
+Caddy is the right tool for the job and allows us to manage the proxy independently from the sites and their individual Ruby requirements.
+
+### Docker
+
+Docker's a bit of a behemoth. It's great when you're deploying to a fleet of servers, but to deploy to a single server, I find it a but excessive. It's also one more tool to understand and learn. Without Docker, there's a few other complexities around managing dependencies, but generally, I feel it's the simpler setup.
+
+### The `deploy` User
+
+I'm not comfortable with the app or any automated tool having access to an account with `sudo` access. As such I designed the setup so we can do everything we need through the `deploy` user without `sudo` access.
+
+## Testing
+
+* Run `bundle exec rake test` to run the test suite
+
+## Contributing
+
+1. Fork it (https://codeberg.org/ayushn21/mimas/fork)
+2. Clone the fork using `git clone` to your local development machine.
+3. Create your feature branch (`git checkout -b my-new-feature`)
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request
+
+## License
+
+Mimas is released under the [MIT License](https://opensource.org/licenses/MIT).
+
+Copyright © 2026 [Ayush Newatia](https://radioactivetoy.tech)

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create

data/bin/mimas

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/mimas"
+
+Dry::CLI.new(Mimas::CLI::Commands).call

data/lib/mimas/archiver.rb

@@ -0,0 +1,68 @@
+require 'zlib'
+require 'rubygems/package'
+
+module Mimas
+  module Archive
+    def archive(root: Dir.pwd, output:, archive_root: "", glob: nil, files: [])
+      Archiver
+        .new(root: root, output: output, archive_root: archive_root, glob: glob, files: files)
+        .package
+    end
+  end
+
+  class Archiver
+    def initialize(root:, output:, archive_root:, glob: nil, files: [])
+      @root = root ||  Dir.pwd
+      @output = output
+      @archive_root = archive_root || ""
+      @glob = glob
+      @source_files = files
+    end
+
+    def package
+      gz = Zlib::GzipWriter.open(@output)
+      tar = Gem::Package::TarWriter.new(gz)
+
+      files.each { add_file(tar, it) }
+
+      tar.close
+      gz.close
+    end
+
+    private
+      def files
+        @files ||=
+          if @glob
+            in_dir(@root) { Dir.glob(@glob) }
+          else
+            @source_files
+          end
+      end
+
+      def add_file(tar, path)
+        source_path = File.expand_path(path, @root)
+        destination_path = File.join(@archive_root, path)
+
+        stat = File.lstat(source_path)
+
+        if stat.directory?
+          tar.mkdir(destination_path, stat.mode)
+        else
+          tar.add_file_simple(destination_path, stat.mode, stat.size) do |io|
+            File.open(source_path, "rb") do |source_file|
+              IO.copy_stream(source_file, io)
+            end
+          end
+        end
+      end
+
+      def in_dir(dir, &block)
+        initial_dir = Dir.pwd
+        Dir.chdir(dir)
+        return_value = yield
+        Dir.chdir(initial_dir)
+
+        return return_value
+      end
+  end
+end

data/lib/mimas/base_command.rb

@@ -0,0 +1,22 @@
+module Mimas
+  module CLI
+    module Commands
+      class BaseCommand < Dry::CLI::Command
+        include Terminal::Printer, SSH, Template
+
+        def initialize
+          super
+
+          if Config.current
+            @hooks = Hooks.new
+            @hooks.merge(Config.current.hooks)
+
+            Plugins.fetch.each do |plugin|
+              @hooks.merge plugin.hooks if plugin.respond_to?(:hooks)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mimas/cli.rb

@@ -0,0 +1,22 @@
+module Mimas
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      register "init", Init
+      register "install ruby", Install
+      register "provision", Provision
+      register "push", Push
+      register "console", Console
+      register "setup caddy", Setup::Caddy
+      register "setup deploy_user", Setup::DeployUser
+      register "setup ruby", Setup::Ruby
+    end
+
+    Plugins.fetch.each do |plugin|
+      plugin.commands.each do |command, target|
+        CLI::Commands.register(command.to_s, target)
+      end
+    end
+  end
+end

data/lib/mimas/commands/console.rb

@@ -0,0 +1,21 @@
+module Mimas
+  module CLI
+    module Commands
+      class Console < BaseCommand
+        desc "Run your app's console"
+
+        argument :server_name, required: true,   desc: "The name of the server to run the console on"
+        argument :site,                          desc: "The site to run the console for. Uses the default site if unspecified"
+
+        def call(server_name, site: :default)
+          server  = Config.current.servers[server_name.to_sym]
+          site    = Config.current.sites[site.to_sym]
+
+          raise "Please add a `console` directive to your config file" unless site.respond_to?(:console)
+
+          server.start_console(site)
+        end
+      end
+    end
+  end
+end