kitsune-kit 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd66d70ec00aa522857e3ac981a13ada8e49aa5723e1a1fc577bc05b7642e250
-  data.tar.gz: 81121119b1abe6a5b70d9fb59efc96994af2ac144b899e96bb5a0098743ee995
+  metadata.gz: 2860b56f9307be49ac06572e05cdf79e02bf76946262e64651d36c729505c8a8
+  data.tar.gz: c38a154d06774e6755dfec97f35a75d4ad2208b262ac37bb3ce20a25612836a7
 SHA512:
-  metadata.gz: 2a49fd2827e0edc77b9a40a8a7b42fef05cb9ba4c6a78655de2419022ec9ad98b703073620643dca76024184557d146e5c67a8fc6536c7596a52a2b13379d5a5
-  data.tar.gz: 8f2d905fd886ba016229e13762e63b9c1997d9289619bf9d3a3793bd222e8a330231884c64d9dba9571a1ebe32fe7f421c84da29e3c064ebce2eb24faa639931
+  metadata.gz: 45ca3cd5d65502bb6c4e2fbdfa965152426d19bb732812651aee0957988d05eff5fe93432758825120e9ac2f20d8041afee8f7d34ac80aab438931c6948c15ad
+  data.tar.gz: f53ede98dd9cbf482e42ed91530cd07ddba5ed1744df1fcc46a92e6e5797f9629180057ff1a5e53cd80987f2ef0892d41400caff2b3a51273310b1676e9f93c5

data/README.md

@@ -18,8 +18,10 @@
 - ♻️ Enables automatic security updates (unattended-upgrades)
 - 💾 Configures swap space for better performance
 - 📊 Installs [DigitalOcean monitoring agent](https://docs.digitalocean.com/products/monitoring/how-to/install-agent/)
+- 🌐 **Automatically links** domains or subdomains (A records) to your server using DigitalOcean DNS
 - 🐳 Installs and configures Docker Engine and private networking
-- 🐘 Deploys PostgreSQL via Docker Compose with healthcheck and `.env`
+- 🐘 Deploys PostgreSQL via Docker Compose with healthcheck
+- 🗄️ Deploys Redis via Docker Compose with healthcheck
 - 🔄 All steps can be rolled back (`--rollback`)
 - ⚡ Fast, reproducible and without relying on YAML or complex external tools
 

data/lib/kitsune/blueprints/.env.template

@@ -7,6 +7,11 @@ IMAGE=
 SSH_KEY_ID=
 TAG_NAME=
 ENABLE_DO_METRICS=true
+# If you want DNS records to be created automatically, set the following variables:
+# DOMAIN_NAMES=example.com,test.example.org # (optional, comma-separated list of domain names to add to the droplet)
+# DNS_TTL=3600 # (optional, time-to-live for DNS records in seconds, default is 3600)
+# Check the DigitalOcean documentation for more information on domain names:
+# https://docs.digitalocean.com/products/networking/dns/getting-started/dns-registrars/
 
 # SSH
 SSH_KEY_PATH=
@@ -17,6 +22,10 @@ SWAP_SIZE_GB=2
 DISABLE_SWAP=false
 
 # PostgreSQL Docker
-POSTGRES_DB=
-POSTGRES_USER=
-POSTGRES_PASSWORD=
+POSTGRES_DB=myapp_db
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=secret
+
+# Redis Docker
+REDIS_PORT=6379
+REDIS_PASSWORD=secret

data/lib/kitsune/blueprints/docker/redis.yml

@@ -0,0 +1,23 @@
+services:
+  redis:
+    image: redis:7.2
+    restart: always
+    ports:
+      - "${REDIS_PORT:-6379}:6379"
+    command: redis-server --requirepass ${REDIS_PASSWORD}
+    networks:
+      - private
+    volumes:
+      - redisdata:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+
+volumes:
+  redisdata:
+
+networks:
+  private:
+    driver: bridge

data/lib/kitsune/kit/ansi_color.rb

@@ -0,0 +1,78 @@
+module AnsiColor
+  COLORS = {
+    black:   30,
+    red:     31,
+    green:   32,
+    yellow:  33,
+    blue:    34,
+    magenta: 35,
+    cyan:    36,
+    white:   37,
+
+    light_black:   90,
+    light_red:     91,
+    light_green:   92,
+    light_yellow:  93,
+    light_blue:    94,
+    light_magenta: 95,
+    light_cyan:    96,
+    light_white:   97
+  }
+
+  BACKGROUNDS = {
+    black:   40,
+    red:     41,
+    green:   42,
+    yellow:  43,
+    blue:    44,
+    magenta: 45,
+    cyan:    46,
+    white:   47,
+
+    light_black:   100,
+    light_red:     101,
+    light_green:   102,
+    light_yellow:  103,
+    light_blue:    104,
+    light_magenta: 105,
+    light_cyan:    106,
+    light_white:   107
+  }
+
+  STYLES = {
+    bold:      1,
+    italic:    3,
+    underline: 4
+  }
+
+  def self.colorize(text, color: nil, background: nil, style: nil)
+    codes = []
+    codes << COLORS[color] if color
+    codes << BACKGROUNDS[background] if background
+    codes << STYLES[style] if style
+
+    raise ArgumentError, "No valid formatting options given" if codes.empty?
+
+    "\e[#{codes.join(';')}m#{text}\e[0m"
+  end
+
+  def self.demo
+    puts "Text Colors:"
+    COLORS.each_key do |color|
+      puts colorize("  #{color.to_s.ljust(15)}", color: color)
+    end
+  
+    puts "\nBackground Colors:"
+    BACKGROUNDS.each_key do |bg|
+      puts colorize("  #{bg.to_s.ljust(15)}", background: bg)
+    end
+  
+    puts "\nStyles:"
+    STYLES.each_key do |style|
+      puts colorize("  #{style.to_s.ljust(15)}", color: :white, style: style)
+    end
+  
+    puts "\nCombined Example:"
+    puts colorize("  bold green on light_black  ", color: :green, background: :light_black, style: :bold)
+  end
+end

data/lib/kitsune/kit/cli.rb

@@ -1,9 +1,10 @@
 require "thor"
-require "colorize"
+require_relative "ansi_color"
 require_relative "env_loader"
 require_relative "commands/init"
 require_relative "commands/switch_env"
 require_relative "commands/provision"
+require_relative "commands/dns"
 require_relative "commands/setup_user"
 require_relative "commands/setup_firewall"
 require_relative "commands/setup_unattended"
@@ -15,18 +16,30 @@ require_relative "commands/install_docker_engine"
 require_relative "commands/postinstall_docker"
 require_relative "commands/bootstrap_docker"
 require_relative "commands/setup_postgres_docker"
+require_relative "commands/setup_redis_docker"
+require_relative "commands/ssh"
 
 module Kitsune
   module Kit
     class CLI < Thor
       def self.dispatch(m, args, options, config)
-        unless ["init", "switch_env", "help", nil].include?(args.first)
+        if args.include?("-v") || args.include?("--version")
+          puts "Kitsune Kit v#{Kitsune::Kit::VERSION}"
+          exit(0)
+        end
+      
+        unless ["version", "init", "switch_env", "help", nil].include?(args.first)
           Kitsune::Kit::EnvLoader.load!
         end
 
         super
       end
 
+      desc "version", "Show Kitsune Kit version"
+      def version
+        say "Kitsune Kit v#{Kitsune::Kit::VERSION}", :green
+      end
+
       desc "init", "Initialize Kitsune Kit project structure"
       subcommand "init", Kitsune::Kit::Commands::Init
 
@@ -36,6 +49,9 @@ module Kitsune
       desc "provision SUBCOMMAND", "Provisioning tasks"
       subcommand "provision", Kitsune::Kit::Commands::Provision
 
+      desc "dns SUBCOMMAND", "Manage DNS"
+      subcommand "dns", Kitsune::Kit::Commands::Dns
+
       desc "setup_user SUBCOMMAND", "Create or rollback deploy user on remote server"
       subcommand "setup_user", Kitsune::Kit::Commands::SetupUser
 
@@ -68,6 +84,12 @@ module Kitsune
 
       desc "setup_postgres_docker SUBCOMMAND", "Setup PostgreSQL via Docker Compose on remote server"
       subcommand "setup_postgres_docker", Kitsune::Kit::Commands::SetupPostgresDocker
+
+      desc "setup_redis_docker SUBCOMMAND", "Setup Redis via Docker Compose on remote server"
+      subcommand "setup_redis_docker", Kitsune::Kit::Commands::SetupRedisDocker
+
+      desc "ssh connect", "SSH into the server"
+      subcommand "ssh", Kitsune::Kit::Commands::Ssh
     end
   end
 end

data/lib/kitsune/kit/commands/bootstrap.rb

@@ -44,6 +44,7 @@ module Kitsune
             run_cli("setup_unattended create", droplet_ip, filled_options)
             run_cli("setup_swap create", droplet_ip, filled_options)
             run_cli("setup_do_metrics create", droplet_ip, filled_options)
+            run_cli("dns link", droplet_ip, filled_options.merge(domains: ENV["DOMAIN_NAMES"]))
           end
 
           def rollback_sequence(filled_options)
@@ -75,10 +76,11 @@ module Kitsune
             run_cli("setup_user rollback", droplet_ip, filled_options)
 
             unless filled_options[:keep_server]
+              run_cli("dns rollback", droplet_ip, filled_options.merge(domains: ENV["DOMAIN_NAMES"]))
               say "▶️ Running: kitsune kit provision rollback", :blue
               Kitsune::Kit::CLI.start(%w[provision rollback])
             else
-              say "⏭️  Skipping droplet deletion (--keep-server enabled)", :yellow
+              say "⏭️  Skipping droplet deletion (--keep-server enabled), DNS rollback won't be executed", :yellow
             end
           end
 
@@ -99,12 +101,18 @@ module Kitsune
           def run_cli(command, droplet_ip, filled_options)
             say "\n▶️ Running: kitsune kit #{command} --server-ip #{droplet_ip}", :blue
             subcommand, action = command.split(" ", 2)
-            Kitsune::Kit::CLI.start([
-              subcommand, action,
-              "--server-ip", droplet_ip,
-              "--ssh-port", filled_options[:ssh_port],
-              "--ssh-key-path", filled_options[:ssh_key_path]
-            ])
+
+            args = [subcommand, action, "--server-ip", droplet_ip]
+
+            if subcommand != "dns"
+              args += ["--ssh-port", filled_options[:ssh_port], "--ssh-key-path", filled_options[:ssh_key_path]]
+            end
+
+            if subcommand == "dns" && ENV["DOMAIN_NAMES"]
+              args += ["--domains", ENV["DOMAIN_NAMES"]]
+            end
+
+            Kitsune::Kit::CLI.start(args)
           rescue SystemExit => e
             abort "❌ Command failed: #{command} (exit #{e.status})"
           end

data/lib/kitsune/kit/commands/dns.rb

@@ -0,0 +1,112 @@
+require "droplet_kit"
+require "thor"
+
+module Kitsune
+  module Kit
+    module Commands
+      class Dns < Thor
+        namespace "dns"
+
+        class_option :domains, type: :string, desc: "Comma-separated domain list (or from ENV['DOMAIN_NAMES'])"
+        class_option :server_ip, type: :string, required: true, desc: "IPv4 to assign to domain(s)"
+        class_option :ttl, type: :numeric, default: 3600, desc: "TTL in seconds for DNS records"
+
+        desc "link", "Link domains to a given IP using A records"
+        def link
+          validate_ip!
+
+          domains = resolve_domains
+          return if domains.empty?
+
+          ip = options[:server_ip]
+          ttl = ENV.fetch("DNS_TTL", options[:ttl]).to_i
+
+          client = DropletKit::Client.new(access_token: ENV.fetch("DO_API_TOKEN"))
+
+          domains.each do |fqdn|
+            parts = fqdn.split('.')
+            next if parts.size < 2
+
+            root_domain = parts[-2..].join('.')
+            subdomain = parts[0..-3].join('.')
+            name_for_a = subdomain.empty? ? "@" : subdomain
+
+            puts "\n🌐 Linking '#{fqdn}' to IP #{ip} (domain: #{root_domain}, record: #{name_for_a})"
+
+            records = client.domain_records.all(for_domain: root_domain)
+            existing = records.find { |r| r.type == "A" && r.name == name_for_a }
+
+            domain_record = DropletKit::DomainRecord.new(
+              type: "A",
+              name: name_for_a,
+              data: ip,
+              ttl: ttl
+            )
+
+            msg = "'#{AnsiColor.colorize(name_for_a, color: :green)}.#{AnsiColor.colorize(root_domain, color: :green)}' → #{AnsiColor.colorize(ip, color: :light_cyan)}"
+            if existing
+              client.domain_records.update(
+                domain_record,
+                for_domain: root_domain,
+                id: existing.id
+              )
+              puts "✅ Updated A record #{msg}"
+            else
+              client.domain_records.create(
+                domain_record,
+                for_domain: root_domain
+              )
+              puts "✅ Created A record #{msg}"
+            end
+          end
+        end
+
+        desc "rollback", "Remove A records for the specified domains"
+        def rollback
+          domains = resolve_domains
+          return if domains.empty?
+
+          client = DropletKit::Client.new(access_token: ENV.fetch("DO_API_TOKEN"))
+
+          domains.each do |fqdn|
+            parts = fqdn.split('.')
+            next if parts.size < 2
+
+            root_domain = parts[-2..].join('.')
+            subdomain = parts[0..-3].join('.')
+            name_for_a = subdomain.empty? ? "@" : subdomain
+
+            puts "\n🗑️ Attempting to delete A record for '#{fqdn}' (domain: #{root_domain}, record: #{name_for_a})"
+
+            records = client.domain_records.all(for_domain: root_domain)
+            existing = records.find { |r| r.type == "A" && r.name == name_for_a }
+
+            if existing
+              client.domain_records.delete(for_domain: root_domain, id: existing.id)
+              puts "✅ Deleted A record '#{name_for_a}.#{root_domain}'"
+            else
+              puts "💡 No A record found for '#{name_for_a}.#{root_domain}', nothing to delete"
+            end
+          end
+        end
+
+        no_commands do
+          def validate_ip!
+            if options[:server_ip].nil? || options[:server_ip].empty?
+              abort "❌ Missing required option: --server-ip"
+            end
+          end
+
+          def resolve_domains
+            raw = options[:domains] || ENV["DOMAIN_NAMES"]
+            if raw.nil? || raw.strip.empty?
+              puts "⏭️  No domains provided. Skipping DNS operation."
+              return []
+            end
+            raw.split(',').map(&:strip).reject(&:empty?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kitsune/kit/commands/init.rb

@@ -124,8 +124,8 @@ module Kitsune
           end
 
           def copy_docker_templates
-            dest_path = ".kitsune/docker/postgres.yml"
-            copy_with_prompt(blueprint_path("docker/postgres.yml"), dest_path)
+            copy_with_prompt(blueprint_path("docker/postgres.yml"), ".kitsune/docker/postgres.yml")
+            copy_with_prompt(blueprint_path("docker/redis.yml"), ".kitsune/docker/redis.yml")
           end
 
           def copy_with_prompt(source, destination)

data/lib/kitsune/kit/commands/setup_do_metrics.rb

@@ -26,7 +26,7 @@ module Kitsune
             defaults: Kitsune::Kit::Defaults.ssh
           )
 
-          with_ssh(filled_options) do |ssh|
+          with_ssh_connection(filled_options) do |ssh|
             install_agent(ssh)
           end
         end
@@ -39,13 +39,13 @@ module Kitsune
             defaults: Kitsune::Kit::Defaults.ssh
           )
 
-          with_ssh(filled_options) do |ssh|
+          with_ssh_connection(filled_options) do |ssh|
             uninstall_agent(ssh)
           end
         end
 
         no_commands do
-          def with_ssh(filled_options)
+          def with_ssh_connection(filled_options)
             Net::SSH.start(
               filled_options[:server_ip],
               "deploy",

data/lib/kitsune/kit/commands/setup_postgres_docker.rb

@@ -36,11 +36,7 @@ module Kitsune
           )
 
           with_ssh_connection(filled_options) do |ssh|
-            perform_setup(ssh, postgres_defaults)
-
-            database_url = build_database_url(filled_options, postgres_defaults)
-            say "🔗 Your DATABASE_URL is:\t", :cyan
-            say database_url, :green
+            perform_setup(ssh, postgres_defaults, filled_options)
           end
         end
 
@@ -71,26 +67,21 @@ module Kitsune
             end
           end
 
-          def perform_setup(ssh, postgres_defaults)
-            docker_compose_local = ".kitsune/docker/postgres.yml"
-            unless File.exist?(docker_compose_local)
-              say "❌ Docker compose file not found at #{docker_compose_local}.", :red
-              exit(1)
-            end
+          def perform_setup(ssh, postgres_defaults, filled_options)
+            local_compose = ".kitsune/docker/postgres.yml"
+            remote_dir = "$HOME/docker/postgres"
+            compose_remote = "#{remote_dir}/docker-compose.yml"
+            env_remote = "#{remote_dir}/.env"
+            marker = "/usr/local/backups/setup_postgres_docker.after"
 
-            docker_dir_remote = "$HOME/docker/postgres"
-            docker_compose_remote = "#{docker_dir_remote}/docker-compose.yml"
-            docker_env_remote = "#{docker_dir_remote}/.env"
-            backup_marker = "/usr/local/backups/setup_postgres_docker.after"
+            abort "❌ Missing #{local_compose}" unless File.exist?(local_compose)
 
             # 1. Create base directory securely
-            ssh.exec!("mkdir -p #{docker_dir_remote}")
-            ssh.exec!("chmod 700 #{docker_dir_remote}")
+            ssh.exec!("mkdir -p #{remote_dir} && chmod 700 #{remote_dir}")
 
             # 2. Upload docker-compose.yml
-            say "📦 Uploading docker-compose.yml to remote server...", :cyan
-            content_compose = File.read(docker_compose_local)
-            upload_file(ssh, content_compose, docker_compose_remote)
+            say "📦 Uploading docker-compose.yml to #{remote_dir}", :cyan
+            upload_file(ssh, File.read(local_compose), compose_remote)
 
             # 3. Create .env file for docker-compose based on postgres_defaults
             say "📦 Creating .env file for Docker Compose...", :cyan
@@ -101,17 +92,17 @@ module Kitsune
               POSTGRES_PORT=#{postgres_defaults[:postgres_port]}
               POSTGRES_IMAGE=#{postgres_defaults[:postgres_image]}
             ENVFILE
-            upload_file(ssh, env_content, docker_env_remote)
+            upload_file(ssh, env_content, env_remote)
 
             # 4. Secure file permissions
-            ssh.exec!("chmod 600 #{docker_compose_remote} #{docker_env_remote}")
+            ssh.exec!("chmod 600 #{compose_remote} #{env_remote}")
 
             # 5. Create backup marker
-            ssh.exec!("sudo mkdir -p /usr/local/backups && sudo touch #{backup_marker}")
+            ssh.exec!("sudo mkdir -p /usr/local/backups && sudo touch #{marker}")
 
             # 6. Validate docker-compose.yml
             say "🔍 Validating docker-compose.yml...", :cyan
-            validation_output = ssh.exec!("cd #{docker_dir_remote} && docker compose config")
+            validation_output = ssh.exec!("cd #{remote_dir} && docker compose config")
             say validation_output, :cyan
 
             # 7. Check if container is running
@@ -119,19 +110,20 @@ module Kitsune
 
             if container_status.empty?
               say "▶️ No running container. Running docker compose up...", :cyan
-              ssh.exec!("cd #{docker_dir_remote} && docker compose up -d")
+              ssh.exec!("cd #{remote_dir} && docker compose up -d")
             else
               say "⚠️ PostgreSQL container is already running.", :yellow
               if yes?("🔁 Recreate the container with updated configuration? [y/N]", :yellow)
                 say "🔄 Recreating container...", :cyan
-                ssh.exec!("cd #{docker_dir_remote} && docker compose down -v && docker compose up -d")
+                ssh.exec!("cd #{remote_dir} && docker compose down -v && docker compose up -d")
               else
                 say "⏩ Keeping existing container.", :cyan
               end
             end
 
+            # 8. Check container status
             say "📋 Final container status (docker compose ps):", :cyan
-            docker_ps_output = ssh.exec!("cd #{docker_dir_remote} && docker compose ps --format json")
+            docker_ps_output = ssh.exec!("cd #{remote_dir} && docker compose ps --format json")
 
             if docker_ps_output.nil? || docker_ps_output.strip.empty? || docker_ps_output.include?("no configuration file")
               say "⚠️ docker compose ps returned no valid output.", :yellow
@@ -168,9 +160,13 @@ module Kitsune
               if healthcheck.include?("accepting connections")
                 say "✅ PostgreSQL is up and accepting connections! (attempt #{attempt})", :green
                 success = true
+
+                database_url = build_database_url(filled_options, postgres_defaults)
+                say "🔗 Your DATABASE_URL is:\t", :cyan
+                say database_url, :green
                 break
               else
-                say "⏳ PostgreSQL not ready yet, retrying in 5 seconds... (#{attempt + 1}/#{max_attempts})", :yellow
+                say "⏳ PostgreSQL not ready yet, retrying in 5 seconds... (#{attempt}/#{max_attempts})", :yellow
                 sleep 5
               end
             end
@@ -181,7 +177,7 @@ module Kitsune
 
             # 10. Allow PostgreSQL port through firewall (ufw)
             say "🛡️ Configuring firewall to allow PostgreSQL (port #{postgres_defaults[:postgres_port]})...", :cyan
-            firewall = <<~EOH
+            output = ssh.exec! <<~EOH
               if command -v ufw >/dev/null; then
                 if ! sudo ufw status | grep -q "#{postgres_defaults[:postgres_port]}"; then
                   sudo ufw allow #{postgres_defaults[:postgres_port]}
@@ -192,7 +188,9 @@ module Kitsune
                 echo "⚠️ ufw not found. Skipping firewall configuration."
               fi
             EOH
-            ssh.exec!(firewall)
+            say output
+
+            say "✅ PostgreSQL setup completed successfully!", :green
           end
 
           def perform_rollback(ssh, postgres_defaults)
@@ -227,9 +225,9 @@ module Kitsune
           end
 
           def upload_file(ssh, content, remote_path)
-            escaped_content = Shellwords.escape(content)
+            escaped = Shellwords.escape(content)
             ssh.exec!("mkdir -p #{File.dirname(remote_path)}")
-            ssh.exec!("echo #{escaped_content} > #{remote_path}")
+            ssh.exec!("echo #{escaped} > #{remote_path}")
           end
 
           def build_database_url(filled_options, postgres_defaults)

data/lib/kitsune/kit/commands/setup_redis_docker.rb

@@ -0,0 +1,241 @@
+require "thor"
+require "net/ssh"
+require "fileutils"
+require "shellwords"
+require_relative "../defaults"
+require_relative "../options_builder"
+require "pry"
+module Kitsune
+  module Kit
+    module Commands
+      class SetupRedisDocker < Thor
+        namespace "setup_redis_docker"
+
+        class_option :server_ip, aliases: "-s", required: true, desc: "Server IP address or hostname"
+        class_option :ssh_port, aliases: "-p", desc: "SSH port"
+        class_option :ssh_key_path, aliases: "-k", desc: "Path to SSH private key"
+
+        desc "create", "Setup Redis using Docker Compose on remote server"
+        def create
+          redis_defaults = Kitsune::Kit::Defaults.redis
+
+          if redis_defaults[:redis_password] == "secret"
+            say "⚠️ Warning: You are using the default Redis password ('secret').", :yellow
+            if ENV.fetch("KIT_ENV", "development") == "production"
+              abort "❌ Production environment requires a secure Redis password!"
+            else
+              say "🔒 Please change REDIS_PASSWORD in your .env if needed.", :yellow
+            end
+          end
+
+          filled_options = Kitsune::Kit::OptionsBuilder.build(
+            options,
+            required: [:server_ip],
+            defaults: Kitsune::Kit::Defaults.ssh
+          )
+
+          with_ssh_connection(filled_options) do |ssh|
+            perform_setup(ssh, redis_defaults, filled_options)
+          end
+        end
+
+        desc "rollback", "Remove Redis Docker setup from remote server"
+        def rollback
+          redis_defaults = Kitsune::Kit::Defaults.redis
+
+          filled_options = Kitsune::Kit::OptionsBuilder.build(
+            options,
+            required: [:server_ip],
+            defaults: Kitsune::Kit::Defaults.ssh
+          )
+
+          with_ssh_connection(filled_options) do |ssh|
+            perform_rollback(ssh, redis_defaults)
+          end
+        end
+
+        no_commands do
+          def with_ssh_connection(filled_options)
+            server = filled_options[:server_ip]
+            port   = filled_options[:ssh_port]
+            key    = File.expand_path(filled_options[:ssh_key_path])
+
+            say "🔑 Connecting as deploy@#{server}:#{port}", :green
+            Net::SSH.start(server, "deploy", port: port, keys: [key], non_interactive: true, timeout: 5) do |ssh|
+              yield ssh
+            end
+          end
+
+          def perform_setup(ssh, redis_defaults, filled_options)
+            local_compose = ".kitsune/docker/redis.yml"
+            remote_dir = "$HOME/docker/redis"
+            compose_remote = "#{remote_dir}/docker-compose.yml"
+            env_remote = "#{remote_dir}/.env"
+            marker = "/usr/local/backups/setup_redis_docker.after"
+
+            abort "❌ Missing #{local_compose}" unless File.exist?(local_compose)
+
+            # 1. Create base directory securely
+            ssh.exec!("mkdir -p #{remote_dir} && chmod 700 #{remote_dir}")
+
+            # 2. Upload docker-compose.yml
+            say "📦 Uploading docker-compose.yml to #{remote_dir}", :cyan
+            upload_file(ssh, File.read(local_compose), compose_remote)
+
+            # 3. Create .env file for docker-compose based on redis_defaults
+            env_content = <<~ENVFILE
+              REDIS_PORT=#{redis_defaults[:redis_port]}
+              REDIS_PASSWORD=#{redis_defaults[:redis_password]}
+            ENVFILE
+            upload_file(ssh, env_content, env_remote)
+
+            # 4. Secure file permissions
+            ssh.exec!("chmod 600 #{compose_remote} #{env_remote}")
+
+            # 5. Create a backup marker
+            ssh.exec!("sudo mkdir -p /usr/local/backups && sudo touch #{marker}")
+
+            # 6. Validate docker-compose.yml
+            say "🔍 Validating docker-compose.yml...", :cyan
+            validation_output = ssh.exec!("cd #{remote_dir} && docker compose config")
+            say validation_output, :cyan
+
+            # 7. Check if container is running
+            container_status = ssh.exec!("docker ps --filter 'name=redis' --format '{{.Status}}'").strip
+
+            if container_status.empty?
+              say "▶️ No running container. Running docker compose up...", :cyan
+              ssh.exec!("cd #{remote_dir} && docker compose up -d")
+            else
+              say "⚠️ Redis container is already running.", :yellow
+              if yes?("🔁 Recreate the container with updated configuration? [y/N]", :yellow)
+                say "🔄 Recreating container...", :cyan
+                ssh.exec!("cd #{remote_dir} && docker compose down -v && docker compose up -d")
+              else
+                say "⏩ Keeping existing container.", :cyan
+              end
+            end
+
+            # 8. Check container status
+            say "📋 Final container status (docker compose ps):", :cyan
+            docker_ps_output = ssh.exec!("cd #{remote_dir} && docker compose ps --format json")
+
+            if docker_ps_output.nil? || docker_ps_output.strip.empty? || docker_ps_output.include?("no configuration file")
+              say "⚠️ docker compose ps returned no valid output.", :yellow
+            else
+              begin
+                services = JSON.parse(docker_ps_output)
+                services = [services] if services.is_a?(Hash)
+
+                redis = services.find { |svc| svc["Service"] == "redis" }
+                status = redis && redis["State"]
+                health = redis && redis["Health"]
+
+                if (status == "running" && health == "healthy") || (health == "healthy")
+                  say "✅ Redis container is running and healthy.", :green
+                else
+                  say "⚠️ Redis container is not healthy yet.", :yellow
+                end
+              rescue JSON::ParserError => e
+                say "🚨 Failed to parse docker compose ps output as JSON: #{e.message}", :red
+              end
+            end
+
+            # 9. Check Redis readiness with retries
+            say "🔍 Checking Redis health with retries...", :cyan
+
+            max_attempts = 10
+            attempt = 0
+            success = false
+
+            while attempt < max_attempts
+              attempt += 1
+              healthcheck = ssh.exec!("docker exec $(docker ps -qf name=redis) redis-cli --no-auth-warning -a #{redis_defaults[:redis_password]} PING")
+
+              if healthcheck.strip == "PONG"
+                say "✅ Redis is up and responding to PING! (attempt #{attempt})", :green
+                success = true
+
+                redis_url = build_redis_url(filled_options, redis_defaults)
+                say "🔗 Your REDIS_URL is:\t", :cyan
+                say redis_url, :green
+                break
+              else
+                say "⏳ Redis not ready yet, retrying in 5 seconds... (#{attempt}/#{max_attempts})", :yellow
+                sleep 5
+              end
+            end
+
+            unless success
+              say "❌ Redis did not become ready after #{max_attempts} attempts.", :red
+            end
+
+            # 10. Allow Redis port through firewall (ufw)
+            say "🛡️ Configuring firewall to allow Redis (port #{redis_defaults[:redis_port]})...", :cyan
+            output = ssh.exec! <<~EOH
+              if command -v ufw >/dev/null; then
+                if ! sudo ufw status | grep -q "#{redis_defaults[:redis_port]}"; then
+                  sudo ufw allow #{redis_defaults[:redis_port]}
+                else
+                  echo "💡 Port #{redis_defaults[:redis_port]} is already allowed in ufw."
+                fi
+              else
+                echo "⚠️ ufw not found. Skipping firewall configuration."
+              fi
+            EOH
+            say output
+
+            say "✅ Redis setup completed successfully!", :green
+          end
+
+          def perform_rollback(ssh, defaults)
+            output = ssh.exec! <<~EOH
+              set -e
+          
+              BASE_DIR="$HOME/docker/redis"
+              BACKUP_DIR="/usr/local/backups"
+              SCRIPT_ID="setup_redis_docker"
+              AFTER_FILE="${BACKUP_DIR}/${SCRIPT_ID}.after"
+          
+              if [ -f "$AFTER_FILE" ]; then
+                echo "🔁 Stopping and removing docker containers..."
+                cd "$BASE_DIR"
+                docker compose down -v || true
+          
+                echo "🧹 Cleaning up files..."
+                rm -rf "$BASE_DIR"
+                sudo rm -f "$AFTER_FILE"
+          
+                if command -v ufw >/dev/null; then
+                  echo "🛡️ Removing Redis port from firewall..."
+                  sudo ufw delete allow #{defaults[:redis_port]} || true
+                fi
+              else
+                echo "💡 Nothing to rollback"
+              fi
+          
+              echo "✅ Rollback completed"
+            EOH
+          
+            say output
+          end
+          
+
+          def upload_file(ssh, content, remote_path)
+            escaped = Shellwords.escape(content)
+            ssh.exec!("mkdir -p #{File.dirname(remote_path)}")
+            ssh.exec!("echo #{escaped} > #{remote_path}")
+          end
+
+          def build_redis_url(filled_options, redis_defaults)
+            password = redis_defaults[:redis_password]
+            host     = filled_options[:server_ip]
+            port     = redis_defaults[:redis_port]
+          
+            "redis://:#{password}@#{host}:#{port}/0"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kitsune/kit/commands/ssh.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "thor"
+require "droplet_kit"
+
+module Kitsune
+  module Kit
+    module Commands
+      class Ssh < Thor
+        namespace "ssh"
+        default_task :connect
+
+        desc "connect", "Connect to a remote server via SSH"
+        option :ip, type: :string, desc: "Server IP address (optional)"
+        option :user, type: :string, default: "deploy", desc: "SSH user"
+        def connect
+          Kitsune::Kit::EnvLoader.load!
+
+          ip = options[:ip] || fetch_server_ip
+          user = options[:user]
+          key_path = Kitsune::Kit::Defaults.ssh[:ssh_key_path]
+
+          say "🔗 Connecting to #{user}@#{ip}...", :green
+          exec "ssh -i #{key_path} -o StrictHostKeyChecking=no #{user}@#{ip}"
+        end
+
+        no_commands do
+          def fetch_server_ip
+            token = ENV.fetch("DO_API_TOKEN") { abort "❌ DO_API_TOKEN is missing" }
+
+            client = DropletKit::Client.new(access_token: token)
+            name = Kitsune::Kit::Defaults.infra[:droplet_name]
+
+            droplet = client.droplets.all.find { |d| d.name == name }
+            abort "❌ Droplet '#{name}' not found on DigitalOcean" unless droplet
+
+            ip = droplet.networks.v4.find { |n| n.type == "public" }&.ip_address
+            abort "❌ No public IP found for droplet '#{name}'" unless ip
+
+            ip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kitsune/kit/defaults.rb

@@ -2,11 +2,11 @@ module Kitsune
   module Kit
     module Defaults
       DROPLET = {
-        droplet_name: "app-prod",
+        droplet_name: "app-dev",
         region: "sfo3",
         size: "s-1vcpu-1gb",
         image: "ubuntu-22-04-x64",
-        tag: "rails-prod"
+        tag: "rails-dev"
       }.freeze
 
       SSH = {
@@ -15,11 +15,10 @@ module Kitsune
       }.freeze
 
       POSTGRES = {
-        db_prefix: "myapp_db",
         user: "postgres",
         password: "secret",
         port: "5432",
-        image: "postgres:15"
+        image: "postgres:17"
       }.freeze
 
       SYSTEM = {
@@ -32,6 +31,11 @@ module Kitsune
         enable_do_metrics: true
       }.freeze
 
+      REDIS = {
+        port: "6379",
+        password: "redis:7.2"
+      }.freeze
+
       def self.infra
         {
           droplet_name: ENV.fetch('DROPLET_NAME', DROPLET[:droplet_name]),
@@ -54,7 +58,7 @@ module Kitsune
         env = ENV.fetch('KIT_ENV', 'development')
 
         {
-          postgres_db: ENV.fetch('POSTGRES_DB') { "#{POSTGRES[:db_prefix]}_#{env}" },
+          postgres_db: ENV.fetch('POSTGRES_DB') { "myapp_db_#{env}" },
           postgres_user: ENV.fetch('POSTGRES_USER', POSTGRES[:user]),
           postgres_password: ENV.fetch('POSTGRES_PASSWORD', POSTGRES[:password]),
           postgres_port: ENV.fetch('POSTGRES_PORT', POSTGRES[:port]),
@@ -62,6 +66,13 @@ module Kitsune
         }
       end
 
+      def self.redis
+        {
+          redis_port: ENV.fetch("REDIS_PORT", REDIS[:port]),
+          redis_password: ENV.fetch("REDIS_PASSWORD", REDIS[:password])
+        }
+      end
+
       def self.system
         {
           swap_size_gb: ENV.fetch("SWAP_SIZE_GB", SYSTEM[:swap_size_gb]).to_i,

data/lib/kitsune/kit/env_loader.rb

@@ -18,8 +18,8 @@ module Kitsune
 
         if found
           Dotenv.load(found)
-          puts "🧪 Loaded Kitsune environment from #{found.light_cyan}"
-          puts "=======================================================================\n".light_cyan
+          puts AnsiColor.colorize("🧪 Loaded Kitsune environment from #{found}", color: :light_cyan)
+          puts AnsiColor.colorize("=======================================================================\n", color: :light_cyan)
         else
           puts "⚠️  No Kitsune infra config found for environment '#{env}' (looked for infra.#{env}.env and infra.env)"
         end

data/lib/kitsune/kit/provisioner.rb

@@ -9,9 +9,7 @@ module Kitsune
         @size         = opts[:size]
         @image        = opts[:image]
         @tag          = opts[:tag]
-        @ssh_key_id   = opts[:ssh_key_id] do
-          abort "❌ You must export SSH_KEY_ID or use --ssh_key_id"
-        end
+        @ssh_key_id   = opts[:ssh_key_id] { abort "❌ You must export SSH_KEY_ID or use --ssh_key_id" }
 
         @client       = DropletKit::Client.new(access_token: ENV.fetch("DO_API_TOKEN"))
       end

data/lib/kitsune/kit/version.rb

@@ -2,6 +2,6 @@
 
 module Kitsune
   module Kit
-    VERSION = "0.2.1"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kitsune-kit
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Omar Herrera
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-02 00:00:00.000000000 Z
+date: 2025-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh
@@ -94,20 +94,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: colorize
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.4
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.4
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -184,11 +170,14 @@ files:
 - kitsune-kit-logo.jpg
 - lib/kitsune/blueprints/.env.template
 - lib/kitsune/blueprints/docker/postgres.yml
+- lib/kitsune/blueprints/docker/redis.yml
 - lib/kitsune/blueprints/kit.env.template
 - lib/kitsune/kit.rb
+- lib/kitsune/kit/ansi_color.rb
 - lib/kitsune/kit/cli.rb
 - lib/kitsune/kit/commands/bootstrap.rb
 - lib/kitsune/kit/commands/bootstrap_docker.rb
+- lib/kitsune/kit/commands/dns.rb
 - lib/kitsune/kit/commands/init.rb
 - lib/kitsune/kit/commands/install_docker_engine.rb
 - lib/kitsune/kit/commands/postinstall_docker.rb
@@ -197,9 +186,11 @@ files:
 - lib/kitsune/kit/commands/setup_docker_prereqs.rb
 - lib/kitsune/kit/commands/setup_firewall.rb
 - lib/kitsune/kit/commands/setup_postgres_docker.rb
+- lib/kitsune/kit/commands/setup_redis_docker.rb
 - lib/kitsune/kit/commands/setup_swap.rb
 - lib/kitsune/kit/commands/setup_unattended.rb
 - lib/kitsune/kit/commands/setup_user.rb
+- lib/kitsune/kit/commands/ssh.rb
 - lib/kitsune/kit/commands/switch_env.rb
 - lib/kitsune/kit/defaults.rb
 - lib/kitsune/kit/env_loader.rb