kitsune-kit 0.4.0 → 0.5.0

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

@@ -1,134 +0,0 @@
-require "thor"
-require "stringio"
-require_relative "../defaults"
-require_relative "../options_builder"
-require_relative "../provisioner"
-
-module Kitsune
-  module Kit
-    module Commands
-      class Bootstrap < Thor
-        namespace "bootstrap"
-
-        class_option :rollback, type: :boolean, default: false, desc: "Rollback the setup"
-        class_option :keep_server, type: :boolean, default: false, desc: "Keep server after rollback"
-        class_option :ssh_port, type: :string, desc: "SSH port for server"
-        class_option :ssh_key_path, type: :string, desc: "SSH private key path"
-
-        desc "execute", "Run the full bootstrap process or rollback"
-        def execute
-          filled_options = Kitsune::Kit::OptionsBuilder.build(
-            options,
-            defaults: Kitsune::Kit::Defaults.ssh
-          )
-
-          if filled_options[:rollback]
-            say "🔄 Rolling back server configurations...", :yellow
-            rollback_sequence(filled_options)
-          else
-            say "🏗️ Setting up server from scratch...", :green
-            setup_sequence(filled_options)
-          end
-
-          say "🎉 Done!", :green
-        end
-
-        no_commands do
-          def setup_sequence(filled_options)
-            droplet_ip = fetch_droplet_ip
-
-            say "→ Droplet IP: #{droplet_ip}", :cyan
-
-            run_cli("setup_user create", droplet_ip, filled_options)
-            run_cli("setup_firewall create", droplet_ip, filled_options)
-            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)
-            provision_options = Kitsune::Kit::OptionsBuilder.build(
-              {},
-              defaults: Kitsune::Kit::Defaults::infra
-            )
-
-            provisioner = Kitsune::Kit::Provisioner.new(provision_options)
-
-            if (droplet = provisioner.find_droplet).nil?
-              say "💡 Nothing to rollback.", :green
-              return
-            end
-
-            droplet_ip = provisioner.send(:public_ip, droplet)
-            say "→ Using Droplet IP: #{droplet_ip}", :cyan
-
-            run_cli("setup_do_metrics rollback", droplet_ip, filled_options)
-
-            if ssh_accessible?(droplet_ip, filled_options)
-              run_cli("setup_unattended rollback", droplet_ip, filled_options)
-              run_cli("setup_firewall rollback", droplet_ip, filled_options)
-            else
-              say "⏭️  Skipping unattended-upgrades and firewall rollback (no deploy user)", :yellow
-            end
-
-            run_cli("setup_swap rollback", droplet_ip, filled_options)
-            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), DNS rollback won't be executed", :yellow
-            end
-          end
-
-          def fetch_droplet_ip
-            out = StringIO.new
-            $stdout = out
-            begin
-              Kitsune::Kit::CLI.start(["provision", "create"])
-            ensure
-              $stdout = STDOUT
-            end
-          
-            ip = out.string[/(\d{1,3}\.){3}\d{1,3}/]
-            abort "❌ Could not detect droplet IP!" if ip.nil? || ip.empty?
-            ip
-          end
-
-          def run_cli(command, droplet_ip, filled_options)
-            say "\n▶️ Running: kitsune kit #{command} --server-ip #{droplet_ip}", :blue
-            subcommand, action = command.split(" ", 2)
-
-            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
-
-          def ssh_accessible?(droplet_ip, filled_options)
-            system(
-              "ssh -o BatchMode=yes -o StrictHostKeyChecking=accept-new " \
-              "-p #{filled_options[:ssh_port]} " \
-              "-i #{File.expand_path(filled_options[:ssh_key_path])} " \
-              "deploy@#{droplet_ip} true",
-              out: File::NULL,
-              err: File::NULL
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-require "thor"
-require "open3"
-require_relative "../defaults"
-require_relative "../options_builder"
-
-module Kitsune
-  module Kit
-    module Commands
-      class BootstrapDocker < Thor
-        namespace "bootstrap_docker"
-
-        class_option :server_ip,    aliases: "-s", required: true, desc: "Server IP address or hostname"
-        class_option :ssh_port,     aliases: "-p", desc: "SSH port for server"
-        class_option :ssh_key_path, aliases: "-k", desc: "SSH private key path"
-        class_option :rollback,     type: :boolean, default: false, desc: "Rollback Docker setup steps"
-
-        desc "execute", "Run full Docker setup or rollback sequence"
-        def execute
-          filled_options = Kitsune::Kit::OptionsBuilder.build(
-            options,
-            required: [:server_ip],
-            defaults: Kitsune::Kit::Defaults.ssh
-          )
-
-          if filled_options[:rollback]
-            say "🔄 Rolling back full Docker setup...", :yellow
-            rollback_sequence(filled_options)
-          else
-            say "🐳 Running full Docker setup...", :green
-            setup_sequence(filled_options)
-          end
-
-          say "🎉 Done!", :green
-        end
-
-        no_commands do
-          def setup_sequence(filled_options)
-            run_cli("setup_docker_prereqs create", filled_options)
-            run_cli("install_docker_engine create", filled_options)
-            run_cli("postinstall_docker create", filled_options)
-          end
-
-          def rollback_sequence(filled_options)
-            run_cli("postinstall_docker rollback", filled_options)
-            run_cli("install_docker_engine rollback", filled_options)
-            run_cli("setup_docker_prereqs rollback", filled_options)
-          end
-
-          def run_cli(command, filled_options)
-            say "\n▶️ Running: kitsune kit #{command} --server-ip #{filled_options[:server_ip]}", :blue
-
-            subcommand, action = command.split(" ", 2)
-            Kitsune::Kit::CLI.start([
-              subcommand, action,
-              "--server-ip", filled_options[:server_ip],
-              "--ssh-port",  filled_options[:ssh_port],
-              "--ssh-key-path", filled_options[:ssh_key_path]
-            ])
-          rescue SystemExit => e
-            abort "❌ Command failed: #{command} (exit #{e.status})"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,112 +0,0 @@
-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

@@ -1,148 +0,0 @@
-require "thor"
-require "fileutils"
-
-module Kitsune
-  module Kit
-    module Commands
-      class Init < Thor
-        namespace "init"
-
-        default_task :init
-
-        desc "init", "Initialize Kitsune Kit project structure"
-        def init
-          say "✨ Initializing Kitsune project...", :green
-          create_base_structure
-          selected_envs = select_environments
-          copy_env_templates(selected_envs)
-          selected_default_env = select_default_environment(selected_envs)
-          create_kit_env(selected_default_env)
-          copy_docker_templates
-          say "🎉 Done! '.kitsune/' structure is ready.", :green
-        end
-
-        no_commands do
-          def blueprint_path(relative_path)
-            File.expand_path("../../blueprints/#{relative_path}", __dir__)
-          end
-
-          def create_base_structure
-            dirs = [
-              ".kitsune",
-              ".kitsune/docker"
-            ]
-            dirs.each do |dir|
-              unless Dir.exist?(dir)
-                FileUtils.mkdir_p(dir)
-                say "📂 Created directory: #{dir}", :cyan
-              else
-                say "📂 Directory already exists: #{dir}", :yellow
-              end
-            end
-          end
-
-          def environments_options
-            {
-              "1" => "development",
-              "2" => "production",
-              "3" => "staging",
-              "4" => "test"
-            }
-          end
-
-          def select_environments
-            say "🌎 Which environments do you want to create?", :cyan
-            environments_options.each do |number, env|
-              say "  #{number}) #{env}"
-            end
-            input = ask("➡️  Enter numbers separated by commas (or type 'all') [default: all]:", :yellow)
-            input = input.strip.downcase
-
-            if input.empty? || input == "all"
-              environments_options.values
-            else
-              selected = input.split(",").map(&:strip)
-              environments = selected.map { |num| environments_options[num] }.compact
-              if environments.empty?
-                say "⚠️ Invalid selection. Creating all environments.", :yellow
-                environments_options.values
-              else
-                environments
-              end
-            end
-          end
-
-          def select_default_environment(selected_envs)
-            say "🎯 Which environment should be set as default in '.kitsune/kit.env'?", :cyan
-            selected_envs.each_with_index do |env, index|
-              say "  #{index + 1}) #{env}"
-            end
-            input = ask("➡️  Enter number [default: 1]:", :yellow)
-            input = input.strip
-
-            if input.empty?
-              selected_envs[0] # default to first selected
-            else
-              index = input.to_i - 1
-              if index >= 0 && index < selected_envs.size
-                selected_envs[index]
-              else
-                say "⚠️ Invalid selection. Defaulting to '#{selected_envs[0]}'", :yellow
-                selected_envs[0]
-              end
-            end
-          end
-
-          def create_kit_env(default_env)
-            path = ".kitsune/kit.env"
-            template = File.read(blueprint_path("kit.env.template"))
-            content = template.gsub("KIT_ENV=development", "KIT_ENV=#{default_env}")
-          
-            if File.exist?(path)
-              if yes?("⚠️  File #{path} already exists. Overwrite? [y/N]", :yellow)
-                File.write(path, content)
-                say "✅ Overwritten: #{path}", :cyan
-              else
-                say "⏩ Skipped: #{path}", :yellow
-              end
-            else
-              File.write(path, content)
-              say "📝 Created: #{path}", :cyan
-            end
-
-            say ""
-            say "🎯 Kitsune Kit environment set to: #{default_env}", :green
-            say "📄 Environment file used: .kitsune/infra.#{default_env}.env", :green
-            say ""
-          end
-
-          def copy_env_templates(selected_envs)
-            selected_envs.each do |env|
-              dest_path = ".kitsune/infra.#{env}.env"
-              copy_with_prompt(blueprint_path(".env.template"), dest_path)
-            end
-          end
-
-          def copy_docker_templates
-            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)
-            if File.exist?(destination)
-              if yes?("⚠️  File #{destination} already exists. Overwrite? [y/N]", :yellow)
-                FileUtils.cp(source, destination)
-                say "✅ Overwritten: #{destination}", :cyan
-              else
-                say "⏩ Skipped: #{destination}", :yellow
-              end
-            else
-              FileUtils.cp(source, destination)
-              say "📝 Created: #{destination}", :cyan
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,146 +0,0 @@
-require "thor"
-require "net/ssh"
-require_relative "../defaults"
-require_relative "../options_builder"
-
-module Kitsune
-  module Kit
-    module Commands
-      class InstallDockerEngine < Thor
-        namespace "install_docker_engine"
-
-        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 your private SSH key"
-
-        desc "create", "Install Docker Engine on the remote server"
-        def create
-          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)
-          end
-        end
-
-        desc "rollback", "Uninstall Docker Engine from the remote server"
-        def rollback
-          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)
-          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)
-            output = ssh.exec! <<~EOH
-              set -e
-
-              sudo mkdir -p /usr/local/backups
-              sudo chown deploy:deploy /usr/local/backups
-
-              BACKUP_DIR="/usr/local/backups"
-              SCRIPT_ID="install_docker_engine"
-              BEFORE_FILE="${BACKUP_DIR}/${SCRIPT_ID}.before"
-              AFTER_FILE="${BACKUP_DIR}/${SCRIPT_ID}.after"
-
-              TARGET_PKGS=(docker-ce docker-ce-cli containerd.io)
-
-              echo "✍🏻 TARGET_PKGS=(\${TARGET_PKGS[*]})"
-
-              if [ ! -f "$AFTER_FILE" ]; then
-                for pkg in "\${TARGET_PKGS[@]}"; do
-                  if dpkg -l "\$pkg" &>/dev/null; then
-                    echo "\$pkg" >> "$BEFORE_FILE"
-                  fi
-                done
-
-                if [ ! -f /usr/share/keyrings/docker-archive-keyring.gpg ]; then
-                  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
-                fi
-
-                if [ ! -f /etc/apt/sources.list.d/docker.list ]; then
-                  echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
-                fi
-
-                echo "✍🏻 Installing Docker Engine..."
-                sudo apt-get update -y
-                sudo apt-get install -y "\${TARGET_PKGS[@]}"
-                sudo touch "$AFTER_FILE" && echo "   - marker at $AFTER_FILE"
-                echo "✅ Docker installed"
-              else
-                echo "🔄 Docker already set up, ensuring latest..."
-                sudo apt-get update -y
-                sudo apt-get install -y "\${TARGET_PKGS[@]}"
-                echo "✅ Docker packages are current"
-              fi
-            EOH
-            say output
-            say "✅ Docker Engine setup completed", :green
-          end
-
-          def perform_rollback(ssh)
-            output = ssh.exec! <<~EOH
-              set -e
-
-              sudo mkdir -p /usr/local/backups
-              sudo chown deploy:deploy /usr/local/backups
-
-              BACKUP_DIR="/usr/local/backups"
-              SCRIPT_ID="install_docker_engine"
-              BEFORE_FILE="${BACKUP_DIR}/${SCRIPT_ID}.before"
-              AFTER_FILE="${BACKUP_DIR}/${SCRIPT_ID}.after"
-
-              TARGET_PKGS=(docker-ce docker-ce-cli containerd.io)
-
-              echo "✍🏻 TARGET_PKGS=(\${TARGET_PKGS[*]})"
-
-              if [ -f "$AFTER_FILE" ]; then
-                to_remove=()
-                for pkg in "\${TARGET_PKGS[@]}"; do
-                  if dpkg -l "\$pkg" &>/dev/null && ! grep -Fxq "\$pkg" "$BEFORE_FILE"; then
-                    to_remove+=("\$pkg")
-                  fi
-                done
-
-                if [ \${#to_remove[@]} -gt 0 ]; then
-                  echo "🔁 Removing Docker packages..."
-                  sudo apt-get remove -y "\${to_remove[@]}" && echo "   - removed: \${to_remove[*]}"
-                else
-                  echo "   - no Docker packages to remove"
-                fi
-
-                sudo rm -f "$BEFORE_FILE" "$AFTER_FILE" && echo "   - cleanup markers"
-              else
-                echo "   - no marker for $SCRIPT_ID, skipping"
-              fi
-
-              echo "✅ Rollback done"
-            EOH
-            say output
-            say "✅ Docker Engine rollback completed", :green
-          end
-        end
-      end
-    end
-  end
-end