caput 0.9.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8f70afda0863b53a3471a330a939a2a16e6c11bf54bf091cde7f868ec8d24af8
+  data.tar.gz: 18b1cad9051efcaaa9f98f8f9cfb3f34283b94e02d8a49451bcb8df7264ba43f
+SHA512:
+  metadata.gz: c68f1efe34c294399396b0b04b2fd5284ee88e08b9c36a4696dcd11a979e21eab145e8f76152d65f35580b3f86edc20e784d26d9b481172b9537ecbbf477ec85
+  data.tar.gz: 670fcae494a9817033ab253ec75eade086399cf314691417a0ceb1326c7a217a7fd3e94ae1a2dd3bbdb958604322b40c92714496ac4c203ca5f110a14aadb112

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2025 Martin Bergek
+
+MIT License
+
+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,92 @@
+
+# Caput
+
+**Caput** is a Ruby gem that helps you prepare a vanilla Ubuntu server to host one or more Rails applications. It automates the steps required to make an application ready for deployment with standard Capistrano commands.
+
+**Note:** Caput does **not deploy the application itself**. Instead, it ensures that the server and the local repository are properly configured so that deployments can be done reliably with minimal manual steps.
+
+Deploying Rails applications to a server can be surprisingly complex. While tools like Kamal provide a modern “official” deployment approach, they often require a public container registry and additional infrastructure that many teams do not want or need. On the other hand, Capistrano has been the tried-and-true method for decades, but its setup can be tedious, especially on a fresh Ubuntu server. This gem bridges the gap: it gives you a simple Capistrano-style workflow while preparing the server and the app environment, without requiring Passenger or complex container setups. Essentially, it automates the repetitive steps needed to make a Rails app server-ready, letting you focus on your app instead of manual server configuration.
+
+---
+
+## Installation
+
+Add the gem to your Rails application's `Gemfile` in the development group:
+
+```ruby
+group :development do
+  gem 'caput', '~> 0.1.0'
+end
+```
+
+Or install it directly:
+
+```bash
+gem install caput
+```
+
+---
+
+## Usage
+
+### 1. Initialise
+
+Run the following in the root folder of your Rails application:
+
+```bash
+caput init
+```
+
+This creates a `caput.conf` file containing configuration for your server and deployment settings.
+
+### 2. Configure
+
+Edit `caput.conf` with the correct values for your setup:
+
+- `setup_user` — user on the server with sudo access  
+- `deploy_user` — user that will own the app directories  
+- `server` — hostname or IP of the server  
+- `app_name` — short name for the Rails application  
+- `hostname` — the hostname that will be used to access the app (DNS must resolve)
+
+> Make sure MySQL and Nginx are installed on the server. Caput will notify you if these dependencies are missing.
+
+### 3. Prepare the server
+
+Run:
+
+```bash
+caput server
+```
+
+Caput will:
+
+- Validate prerequisites (MySQL client/server, Nginx, setup user, DNS)  
+- Create the Capistrano-compatible folder structure 
+- Set up a **systemd service** for Puma to serve requests in the background  
+- Configure permissions for the `deploy` user  
+
+> Caput does not deploy the Rails app. After this, you can deploy using standard Capistrano commands.
+
+### 4. Configure the local repository
+
+Run:
+
+```bash
+caput local
+```
+
+This will:
+
+- Add Capistrano configuration and necessary files to your local Rails repository  
+- Make the repository ready for deployments  
+
+> Currently, `caput server` and `caput local` must be run separately, in that order. In the future, these may be combined into a single `caput setup` command.
+
+---
+
+## Notes
+
+- Only a few prerequisites must be handled manually: MySQL, Nginx, setup user with sudo access, and DNS for the application hostname.  
+- Caput is designed to allow hosting multiple Rails applications on the same server. Each application gets its own folder structure, systemd service, and Nginx configuration.
+

data/exe/caput

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'caput'
+Caput::CLI.start(ARGV)

data/lib/caput/cli.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'caput/config'
+require 'caput/remote'
+require 'caput/server'
+require 'caput/local'
+require 'caput/teardown'
+
+module Caput
+  class CLI < Thor
+    desc 'init', 'Create a local caput.conf with sample settings'
+    def init
+      Caput::Config.init_config
+    end
+
+    desc 'server', 'Prepare the remote server for deployment'
+    def server
+      Caput::Config.load_config!
+      Caput::Server.check_dependencies
+      Caput::Server.prepare
+    end
+
+    desc 'local', 'Prepare the local Rails application for Capistrano'
+    def local
+      Caput::Config.load_config!
+      Caput::Local.prepare
+    end
+
+    desc 'teardown', 'Remove application-specific server configuration'
+    def teardown
+      Caput::Config.load_config!
+      Caput::Teardown.run
+    end
+  end
+end

data/lib/caput/config.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Caput
+  module Config
+    CONFIG_FILE = 'caput.conf'
+
+    def self.init_config
+      return puts 'Configuration file already exists.' if File.exist?(CONFIG_FILE)
+      File.write(CONFIG_FILE, <<~CONF)
+        # Sample configuration for caput deployment
+
+        # Name of the application. This name will be used for the nginx site as well
+        # as for the Puma service definition.
+        APP_NAME="myapp"
+
+        # Setup user on the server. Note that this user should have passwordless sudo
+        # access on the server. This user is only used while setting up the application.
+        # This user must exist on the server, if it doesn't the script will notify the user
+        # and exit.
+        SETUP_USER="setup"
+
+        # Deploy user on the server. This is the user that will own the application and also
+        # run the Puma process that will run the application. If this user does not exist it
+        # will be created.
+        DEPLOY_USER="deploy"
+
+        # Target server hostname or IP. This is the address to which the application will be
+        # deployed. It does not, however, have to be the hostname of the application itself, and
+        # in most cases it will not be.
+        SERVER="example.com"
+
+        # Domain for nginx site. This is the hostname that users will enter in their browsers
+        # to reach the application. DNS configuration is assumed to have been done prior to
+        # installing the application using this script.
+        DOMAIN="www.example.com"
+
+        # Ruby version to use with rbenv. This version will be installed via rbenv on the server.
+        # It needs to match the RUBY version used by the Ruby on Rails application being deployed.
+        RUBY_VERSION="3.2.2"
+
+        # Path on the server where app will be deployed. This will be the root directory on the
+        # server where the Ruby on Rails application will be deployed by Capistrano.
+        DEPLOY_PATH="/var/www/myapp"
+
+        # Git repository URL. This will be used to configure the Capistrano deployment files.
+        REPO_URL="git@example.com:username/myapp.git"
+      CONF
+      puts "Created #{CONFIG_FILE}"
+    end
+
+    def self.load_config!
+      unless File.exist?(CONFIG_FILE)
+        abort "Configuration file #{CONFIG_FILE} not found! Run `caput init`."
+      end
+      @config = {}
+      File.readlines(CONFIG_FILE).each do |line|
+        next if line.strip.empty? || line.strip.start_with?('#')
+        if line =~ /^(\w+)=(?:"(.*)"|'(.*)'|(.*))$/
+          key = $1
+          val = $2 || $3 || $4
+          @config[key] = val.to_s
+        end
+      end
+      # populate ENV for backwards compatibility
+      @config.each { |k, v| ENV[k] = v }
+    end
+
+    def self.[](key)
+      @config[key]
+    end
+  end
+end

data/lib/caput/local.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'config'
+
+module Caput
+  module Local
+    extend self
+
+    def prepare
+      app_name = Caput::Config['APP_NAME']
+      repo_url = Caput::Config['REPO_URL']
+      deploy_path = Caput::Config['DEPLOY_PATH']
+      ruby_version = Caput::Config['RUBY_VERSION']
+      server = Caput::Config['SERVER']
+      deploy_user = Caput::Config['DEPLOY_USER']
+
+      puts "Preparing local Rails application..."
+
+      unless bundle_has?('capistrano')
+        puts "Adding Capistrano gems to Gemfile..."
+        system('bundle add capistrano capistrano-rails capistrano-rbenv')
+      end
+
+      puts "Running bundle install..."
+      system('bundle install')
+
+      unless File.exist?('Capfile')
+        puts "Running 'cap install' to create Capfile and config directories..."
+        system('bundle exec cap install')
+      end
+
+      ensure_file_contains('Capfile', "require 'capistrano/rails'")
+      ensure_file_contains('Capfile', "require 'capistrano/rbenv'")
+
+      FileUtils.mkdir_p('config/deploy')
+      deploy_rb = 'config/deploy.rb'
+      backup_file(deploy_rb)
+      File.open(deploy_rb, 'a') do |f|
+        f.puts <<~DEPLOY
+
+          set :application, "#{app_name}"
+          set :repo_url, "#{repo_url}"
+          set :deploy_to, "#{deploy_path}"
+          set :rbenv_type, :user
+          set :rbenv_ruby, "#{ruby_version}"
+          set :puma_bind, "unix://#{deploy_path}/shared/tmp/sockets/puma.sock"
+          set :puma_pid, "#{deploy_path}/shared/tmp/pids/puma.pid"
+          ask :branch, `git rev-parse --abbrev-ref HEAD`.chomp
+          set :linked_files, fetch(:linked_files, []).push('config/master.key')
+        DEPLOY
+      end
+
+      File.open('config/deploy/production.rb', 'a') do |f|
+        f.puts "server \"#{server}\", user: \"#{deploy_user}\", roles: %w{app db web}"
+      end
+
+      FileUtils.mkdir_p(['tmp/pids', 'tmp/sockets', 'log'])
+
+      puts "\nLocal application prepared. You can now run:\n\n  bundle exec cap production deploy"
+    end
+
+    def bundle_has?(gem_name)
+      out = `bundle list --name-only 2>/dev/null || true`
+      out.split("\n").any? { |l| l.include?(gem_name) }
+    end
+
+    def ensure_file_contains(path, line)
+      return unless File.exist?(path)
+      content = File.read(path)
+      unless content.include?(line)
+        File.open(path, 'a') { |f| f.puts line }
+      end
+    end
+
+    def backup_file(path)
+      return unless File.exist?(path)
+      bak = "#{path}.bak"
+      FileUtils.cp(path, bak)
+    end
+  end
+end

data/lib/caput/remote.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'net/ssh'
+require 'net/scp'
+require 'tempfile'
+
+module Caput
+  class Remote
+    def initialize(user:, host:, ssh_options: {})
+      @user = user
+      @host = host
+      @ssh_options = ssh_options
+    end
+
+    def exec!(cmd)
+      exit_status = nil
+      ssh_options = @options || {}
+
+      Net::SSH.start(@host, @user, ssh_options) do |ssh|
+        ssh.open_channel do |ch|
+          ch.exec("bash -l") do |_, success|
+            raise "could not start bash" unless success
+
+            ch.on_data { |_, data| $stdout.print data }
+            ch.on_extended_data { |_, _, data| $stderr.print data }
+            ch.on_request("exit-status") { |_, data| exit_status = data.read_long }
+
+            ch.send_data(cmd)
+            ch.send_data("\nexit\n")
+            ch.eof!
+          end
+        end
+
+        ssh.loop
+      end
+
+      if exit_status != 0
+        raise "Remote command failed (exit #{exit_status}): #{cmd}"
+      end
+    end
+
+    def upload_content!(content, remote_path, mode: 0644)
+      Tempfile.create do |f|
+        f.binmode
+        f.write(content)
+        f.flush
+        upload_file!(f.path, remote_path, mode: mode)
+      end
+    end
+
+    def upload_file!(local_path, remote_path, mode: 0644)
+      Net::SCP.start(@host, @user, **@ssh_options) do |scp|
+        scp.upload!(local_path, remote_path)
+      end
+      exec!("sudo chmod #{sprintf('%o', mode)} #{remote_path}")
+    end
+
+    private
+
+    def escape_for_bash(s)
+      s.gsub('"', '"').gsub('$', '\$')
+    end
+  end
+end

data/lib/caput/server.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require_relative 'remote'
+require_relative 'config'
+
+module Caput
+  module Server
+    extend self
+
+    def check_dependencies
+      setup_user  = Caput::Config['SETUP_USER']
+      server      = Caput::Config['SERVER']
+
+      remote = Caput::Remote.new(user: setup_user, host: server)
+
+      puts "\nValidating server dependencies..."
+
+      begin
+        # Check for MySQL server
+        remote.exec!(<<~BASH)
+          if ! command -v mysql >/dev/null 2>&1; then
+            echo "ERROR: MySQL client/server not installed" >&2
+            exit 1
+          fi
+          if ! systemctl is-active --quiet mysql && ! systemctl is-active --quiet mariadb; then
+            echo "ERROR: MySQL/MariaDB service is not running" >&2
+            exit 1
+          fi
+        BASH
+        
+        # Check for nginx
+        remote.exec!(<<~BASH)
+          if ! command -v nginx >/dev/null 2>&1; then
+            echo "ERROR: nginx not installed" >&2
+            exit 1
+          fi
+          if ! systemctl is-active --quiet nginx; then
+            echo "ERROR: nginx service is not running" >&2
+            exit 1
+          fi
+        BASH
+
+      rescue RuntimeError => e
+        exit 1          # stop Caput immediately
+      end
+
+      puts "All dependencies satisfied."
+    end
+
+    def prepare
+      setup_user  = Caput::Config['SETUP_USER']
+      deploy_user = Caput::Config['DEPLOY_USER']
+      server      = Caput::Config['SERVER']
+      app_name    = Caput::Config['APP_NAME']
+      domain      = Caput::Config['DOMAIN']
+      deploy_path = Caput::Config['DEPLOY_PATH']
+      ruby_version = Caput::Config['RUBY_VERSION']
+
+      raise 'Missing configuration: run `caput init` and edit caput.conf' unless setup_user && server && deploy_user && app_name
+
+      check_sudo!(setup_user, server)
+
+      remote = Caput::Remote.new(user: setup_user, host: server)
+
+      puts "\nInstalling system dependencies on remote..."
+      remote.exec!(<<~BASH)
+        sudo apt-get update || true
+        sudo apt-get install -y git curl build-essential libssl-dev libreadline-dev zlib1g-dev libffi-dev libyaml-dev libgdbm-dev libncurses-dev libdb-dev libsqlite3-dev libgmp-dev libbz2-dev autoconf bison pkg-config liblzma-dev libxml2-dev libxslt1-dev libcurl4-openssl-dev nginx || true
+      BASH
+
+      puts "\nVerify deploy user account..."
+      remote.exec!(<<~BASH)
+        if getent passwd #{deploy_user} >/dev/null 2>&1; then
+          echo "Deploy user already exists"
+        else
+          echo "Creating deploy user #{deploy_user}"
+          sudo adduser --disabled-password --gecos "" #{deploy_user}
+        fi
+      BASH
+
+      puts "\nEnsure deploy authorized_keys and home..."
+      remote.exec!(<<~BASH)
+        DEPLOY_HOME="$(getent passwd #{deploy_user} | cut -d: -f6)"
+        DEPLOY_SSH_DIR="$DEPLOY_HOME/.ssh"
+        SETUP_HOME="$(getent passwd #{setup_user} | cut -d: -f6)"
+
+        sudo mkdir -p "$DEPLOY_SSH_DIR"
+        sudo chown #{deploy_user}:#{deploy_user} "$DEPLOY_SSH_DIR"
+        sudo chmod 700 "$DEPLOY_SSH_DIR"
+
+        AUTH_KEYS="$DEPLOY_SSH_DIR/authorized_keys"
+        if [ ! -s "$AUTH_KEYS" ]; then
+          echo "Copying authorized_keys from setup user"
+          sudo cp "$SETUP_HOME/.ssh/authorized_keys" "$AUTH_KEYS" || true
+          sudo chown #{deploy_user}:#{deploy_user} "$AUTH_KEYS" || true
+          sudo chmod 600 "$AUTH_KEYS" || true
+        else
+          echo "Authorized keys already present"
+        fi
+      BASH
+
+      puts "\nCreate deploy directories..."
+      remote.exec!(<<~BASH)
+        if [ -d "#{deploy_path}" ]; then
+          echo "Deploy directories already exist"
+        else
+          sudo mkdir -p "#{deploy_path}/shared/tmp/pids" "#{deploy_path}/shared/tmp/sockets" "#{deploy_path}/shared/log"
+          sudo chown -R #{deploy_user}:#{deploy_user} "#{deploy_path}"
+        fi
+      BASH
+
+      puts "\nInstall Nginx site config..."
+      nginx_conf = <<~NGINX
+        server {
+            listen 80;
+            server_name #{domain};
+
+            root #{deploy_path}/current/public;
+
+            location / {
+                try_files $uri @puma;
+            }
+
+            location @puma {
+                proxy_pass http://unix:#{deploy_path}/shared/tmp/sockets/puma.sock;
+                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+                proxy_set_header Host $http_host;
+                proxy_redirect off;
+            }
+
+            error_page 500 502 503 504 /500.html;
+        }
+      NGINX
+
+      remote.upload_content!(nginx_conf, "/tmp/#{app_name}.nginx")
+      remote.exec!(<<~BASH)
+        sudo mv /tmp/#{app_name}.nginx /etc/nginx/sites-available/#{app_name}
+        sudo ln -sf /etc/nginx/sites-available/#{app_name} /etc/nginx/sites-enabled/#{app_name}
+        sudo nginx -t
+        sudo systemctl reload nginx
+      BASH
+
+      puts "\nSetup Puma systemd service..."
+      service_file = <<~SERVICE
+        [Unit]
+        Description=Puma HTTP Server for #{app_name}
+        After=network.target
+
+        [Service]
+        Type=simple
+        User=#{deploy_user}
+        WorkingDirectory=#{deploy_path}/current
+        ExecStart=#{deploy_path}/shared/bin/start_puma.sh
+        Restart=always
+
+        [Install]
+        WantedBy=multi-user.target
+      SERVICE
+
+      remote.upload_content!(service_file, "/tmp/#{app_name}-puma.service")
+      remote.exec!(<<~BASH)
+        sudo mv /tmp/#{app_name}-puma.service /etc/systemd/system/#{app_name}-puma.service
+        sudo systemctl daemon-reload
+        sudo systemctl enable #{app_name}-puma
+      BASH
+
+      puts "Create a simple puma.rb and start script in shared (if missing)"
+      puma_rb = <<~PUMA
+        threads 0,16
+        workers 1
+        app_dir = "#{deploy_path}/current"
+        shared_dir = "#{deploy_path}/shared"
+        bind "unix://\#{shared_dir}/tmp/sockets/puma.sock"
+        pidfile "\#{shared_dir}/tmp/pids/puma.pid"
+        stdout_redirect "\#{shared_dir}/log/puma.stdout.log", "\#{shared_dir}/log/puma.stderr.log", true
+      PUMA
+
+      start_sh = <<~SH
+        #!/bin/bash
+        export RBENV_ROOT="$HOME/.rbenv"
+        export PATH="$RBENV_ROOT/bin:$PATH"
+        eval "$(rbenv init -)"
+        cd #{deploy_path}/current || exit 1
+        exec $RBENV_ROOT/shims/bundle exec puma -C #{deploy_path}/shared/puma.rb
+      SH
+
+      remote.upload_content!(puma_rb, "/tmp/puma.rb")
+      remote.exec!("sudo mv -f /tmp/puma.rb #{deploy_path}/shared/puma.rb || true")
+      remote.upload_content!(start_sh, "/tmp/start_puma.sh")
+      remote.exec!(<<~BASH)
+        sudo mkdir -p #{deploy_path}/shared/bin
+        sudo mv -f /tmp/start_puma.sh #{deploy_path}/shared/bin/start_puma.sh
+        sudo chown -R #{deploy_user}:#{deploy_user} #{deploy_path}/shared
+        sudo chmod +x #{deploy_path}/shared/bin/start_puma.sh
+      BASH
+
+      puts "\nInstall rbenv and Ruby for deploy user..."
+      deploy_remote = Caput::Remote.new(user: deploy_user, host: server)
+      deploy_remote.exec!(<<~BASH)
+        RBENV_DIR="$HOME/.rbenv"
+        if [ ! -d "$RBENV_DIR" ]; then
+          git clone https://github.com/rbenv/rbenv.git "$RBENV_DIR"
+          mkdir -p "$RBENV_DIR/plugins"
+          git clone https://github.com/rbenv/ruby-build.git "$RBENV_DIR/plugins/ruby-build"
+        else
+          echo "rbenv already installed"
+        fi
+
+        export RBENV_ROOT="$RBENV_DIR"
+        export PATH="$RBENV_ROOT/bin:$PATH"
+        eval "$(rbenv init -)"
+
+        if ! rbenv versions | grep -q "#{ruby_version}"; then
+          rbenv install "#{ruby_version}" || true
+        else
+          echo "Ruby #{ruby_version} already installed"
+        fi
+
+        rbenv global "#{ruby_version}"
+        rbenv rehash
+
+        if ! grep -q 'rbenv init' ~/.bashrc; then
+          echo 'export RBENV_ROOT=\"$HOME/.rbenv\"' >> ~/.bashrc
+          echo 'export PATH=\"$RBENV_ROOT/bin:$PATH\"' >> ~/.bashrc
+          echo 'eval \"$(rbenv init -)\"' >> ~/.bashrc
+        fi
+
+        gem install bundler --no-document || true
+        rbenv rehash
+      BASH
+
+      puts "\nServer preparation complete."
+    end
+
+    def check_sudo!(user, server)
+      cmd = %{ssh #{user}@#{server} "sudo -n true"}
+      puts "Checking passwordless sudo for #{user}@#{server}..."
+      success = system(cmd)
+      unless success && $?.exitstatus == 0
+        abort <<~MSG
+          Warning: Setup user #{user} does not have passwordless sudo on #{server}.
+          Example sudoers entry:
+            #{user} ALL=(ALL) NOPASSWD:ALL
+        MSG
+      end
+    end
+  end
+end

data/lib/caput/teardown.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'remote'
+require_relative 'config'
+
+module Caput
+  module Teardown
+    extend self
+
+    def run
+      setup_user = Caput::Config['SETUP_USER']
+      server = Caput::Config['SERVER']
+      app_name = Caput::Config['APP_NAME']
+
+      raise 'Missing configuration' unless setup_user && server && app_name
+
+      remote = Caput::Remote.new(user: setup_user, host: server)
+
+      puts "Tearing down application-specific server configuration on #{server} ..."
+      remote.exec!(<<~BASH)
+        sudo systemctl stop #{app_name}-puma || true
+        sudo systemctl disable #{app_name}-puma || true
+        sudo rm -f /etc/systemd/system/#{app_name}-puma.service || true
+        sudo systemctl daemon-reload || true
+        sudo rm -f /etc/nginx/sites-available/#{app_name} || true
+        sudo rm -f /etc/nginx/sites-enabled/#{app_name} || true
+        sudo nginx -t || true
+        sudo systemctl reload nginx || true
+      BASH
+
+      puts "Teardown complete."
+    end
+  end
+end

data/lib/caput/version.rb

@@ -0,0 +1,3 @@
+module Caput
+  VERSION = '0.9.5'
+end

data/lib/caput.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'thor'
+#require_relative 'caput/version'
+#require_relative 'caput/cli'
+
+require "caput/cli"
+require "caput/config"
+require "caput/server"
+require "caput/local"
+require "caput/teardown"
+
+module Caput
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: caput
+version: !ruby/object:Gem::Version
+  version: 0.9.5
+platform: ruby
+authors:
+- Martin Bergek
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.3'
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+description: Caput automates the repetitive steps required to make a Rails application
+  ready to deploy on a fresh Ubuntu server. It ensures dependencies are installed,
+  configures users, directories, and permissions, and sets up the environment for
+  Capistrano deployments — all without requiring Passenger or container registries.
+  With Caput, developers can enjoy the simplicity of Capistrano while minimising manual
+  server setup.
+email:
+- contact@spotwise.com
+executables:
+- caput
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/caput
+- lib/caput.rb
+- lib/caput/cli.rb
+- lib/caput/config.rb
+- lib/caput/local.rb
+- lib/caput/remote.rb
+- lib/caput/server.rb
+- lib/caput/teardown.rb
+- lib/caput/version.rb
+homepage: https://github.com/mbergek/caput
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Simplifies preparing Ubuntu servers for Rails apps with a Capistrano-friendly
+  workflow
+test_files: []