kitsune-kit 0.4.0 → 0.5.0

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

@@ -1,132 +0,0 @@
-require "thor"
-require "net/ssh"
-require_relative "../defaults"
-require_relative "../options_builder"
-
-module Kitsune
-  module Kit
-    module Commands
-      class SetupUnattended < Thor
-        namespace "setup_unattended"
-
-        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", "Configure unattended-upgrades 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", "Revert unattended-upgrades configuration on 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
-
-              RESOURCE="/etc/apt/apt.conf.d/20auto-upgrades"
-              BACKUP_DIR="/usr/local/backups"
-              SCRIPT_ID="setup_unattended"
-              BACKUP_FILE="${BACKUP_DIR}/${SCRIPT_ID}.before"
-              MARKER_FILE="${BACKUP_DIR}/${SCRIPT_ID}.after"
-
-              echo "✍🏻 Installing required packages…"
-              if ! dpkg -l | grep -q "^ii\\s*unattended-upgrades"; then
-                sudo apt-get update -y
-                sudo apt-get install -y unattended-upgrades apt-listchanges && echo "   - packages installed"
-              else
-                echo "   - unattended-upgrades already installed"
-              fi
-
-              if [ ! -f "$MARKER_FILE" ]; then
-                echo "✍🏻 Backing up existing config…"
-                sudo cp "$RESOURCE" "$BACKUP_FILE" && echo "   - backup saved to $BACKUP_FILE"
-                sudo touch "$MARKER_FILE" && echo "   - marker created at $MARKER_FILE"
-              else
-                echo "   - backup & marker already exist"
-              fi
-
-              echo "✍🏻 Applying new auto-upgrades config…"
-              sudo tee "$RESOURCE" > /dev/null <<UPGR
-APT::Periodic::Update-Package-Lists "1";
-APT::Periodic::Download-Upgradeable-Packages "1";
-APT::Periodic::AutocleanInterval "7";
-APT::Periodic::Unattended-Upgrade "1";
-UPGR
-              echo "   - config applied"
-
-              echo "✍🏻 Enabling & restarting unattended-upgrades…"
-              sudo systemctl --quiet enable unattended-upgrades.service >/dev/null 2>&1 && echo "   - service enabled"
-              sudo systemctl --quiet restart unattended-upgrades.service && echo "   - service restarted"
-            EOH
-            say output
-            say "✅ Unattended-upgrades 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
-
-              RESOURCE="/etc/apt/apt.conf.d/20auto-upgrades"
-              BACKUP_DIR="/usr/local/backups"
-              SCRIPT_ID="setup_unattended"
-              BACKUP_FILE="${BACKUP_DIR}/${SCRIPT_ID}.before"
-              MARKER_FILE="${BACKUP_DIR}/${SCRIPT_ID}.after"
-
-              if [ -f "$MARKER_FILE" ]; then
-                echo "🔁 Restoring original auto-upgrades config…"
-                sudo mv "$BACKUP_FILE" "$RESOURCE" && echo "   - config restored from $BACKUP_FILE"
-                sudo rm -f "$MARKER_FILE" && echo "   - marker $MARKER_FILE removed"
-              else
-                echo "   - no marker for $SCRIPT_ID, skipping restore"
-              fi
-
-              echo "✍🏻 Stopping & disabling unattended-upgrades…"
-              sudo systemctl --quiet stop unattended-upgrades.service apt-daily.timer apt-daily-upgrade.timer && echo "   - services stopped"
-              sudo systemctl --quiet disable unattended-upgrades.service && echo "   - service disabled"
-            EOH
-            say output
-            say "✅ Unattended-upgrades rollback completed", :green
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,189 +0,0 @@
-require "thor"
-require "net/ssh"
-require_relative "../defaults"
-require_relative "../options_builder"
-
-module Kitsune
-  module Kit
-    module Commands
-      class SetupUser < Thor
-        namespace "setup_user"
-
-        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",   "Create and configure 'deploy' user on remote server"
-        def create
-          filled_options = Kitsune::Kit::OptionsBuilder.build(
-            options,
-            required: [:server_ip],
-            defaults: Kitsune::Kit::Defaults.ssh
-          )
-
-          with_ssh_connection(false, filled_options) do |ssh|
-            perform_setup(ssh)
-          end
-        end
-
-        desc "rollback", "Revert configuration and remove 'deploy' user from remote server"
-        def rollback
-          filled_options = Kitsune::Kit::OptionsBuilder.build(
-            options,
-            required: [:server_ip],
-            defaults: Kitsune::Kit::Defaults.ssh
-          )
-
-          server = filled_options[:server_ip]
-          port   = filled_options[:ssh_port]
-          key    = File.expand_path(filled_options[:ssh_key_path])
-
-          # First, attempt SSH config restore as 'deploy'
-          begin
-            with_ssh_connection(true, filled_options) do |ssh|
-              perform_rollback_config(ssh)
-            end
-          rescue StandardError => e
-            say "⚠️ Skipping SSH config restore: #{e.message}", :yellow
-          end
-
-          # Then reconnect as 'root' to remove sudoers and delete user
-          say "🔑 Reconnecting as root@#{server}:#{port}", :green
-          Net::SSH.start(server, 'root', port: port, keys: [key], non_interactive: true) do |ssh|
-            perform_rollback_cleanup(ssh)
-          end
-          say "✅ Rollback completed", :green
-        end
-
-        no_commands do
-          def with_ssh_connection(rollback, filled_options)
-            server = filled_options[:server_ip]
-            port   = filled_options[:ssh_port]
-            key    = File.expand_path(filled_options[:ssh_key_path])
-          
-            user = rollback ? 'deploy' : detect_remote_user(server, port, key)
-            say "🔑 Connecting as #{user}@#{server}:#{port}", :green
-          
-            Net::SSH.start(server, user, port: port, keys: [key], non_interactive: true, timeout: 5) do |ssh|
-              yield ssh
-            end
-          end
-
-          def detect_remote_user(server, port, key)
-            %w[deploy root].each do |u|
-              begin
-                Net::SSH.start(server, u, port: port, keys: [key], non_interactive: true, timeout: 5) { }
-                say "✔️ Able to SSH as #{u}", :green
-                return u
-              rescue
-                next
-              end
-            end
-            abort("❌ Could not connect as deploy or root on #{server}:#{port}")
-          end
-
-          def perform_setup(ssh)
-            output = ssh.exec! <<~'EOH'
-              set -e
-
-              echo "✍🏻 Creating deploy user…"
-              if ! id deploy &>/dev/null; then
-                if command -v adduser &>/dev/null; then
-                  sudo adduser --disabled-password --gecos "" deploy && echo "   - user 'deploy' created"
-                else
-                  sudo useradd -m -s /bin/bash deploy && echo "   - user 'deploy' created"
-                fi
-                sudo usermod -aG sudo deploy && echo "   - 'deploy' added to sudo"
-              else
-                echo "   - user 'deploy' already exists"
-              fi
-
-              echo "✍🏻 Configuring passwordless sudo…"
-              if [ ! -f /etc/sudoers.d/deploy ]; then
-                echo 'deploy ALL=(ALL) NOPASSWD:ALL' | sudo tee /etc/sudoers.d/deploy \
-                  && sudo chmod 440 /etc/sudoers.d/deploy \
-                  && echo "   - sudoers entry created"
-              else
-                echo "   - sudoers entry exists"
-              fi
-
-              echo "✍🏻 Backing up SSH config…"
-              sudo test -f /etc/ssh/sshd_config.bak || sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak && echo "   - sshd_config backed up"
-
-              echo "✍🏻 Hardening SSH…"
-              grep -q '^PermitRootLogin no' /etc/ssh/sshd_config \
-                || sudo sed -i 's/^#*PermitRootLogin .*/PermitRootLogin no/' /etc/ssh/sshd_config && echo "   - PermitRootLogin no"
-              grep -q '^PasswordAuthentication no' /etc/ssh/sshd_config \
-                || sudo sed -i 's/^#*PasswordAuthentication .*/PasswordAuthentication no/' /etc/ssh/sshd_config && echo "   - PasswordAuthentication no"
-              sudo systemctl restart sshd && echo "   - sshd restarted"
-
-              echo "✍🏻 Installing SSH keys for deploy…"
-              if [ ! -f /home/deploy/.ssh/authorized_keys ]; then
-                sudo mkdir -p /home/deploy/.ssh
-                sudo cp /root/.ssh/authorized_keys /home/deploy/.ssh/authorized_keys
-                sudo chown -R deploy:deploy /home/deploy/.ssh
-                sudo chmod 700 /home/deploy/.ssh
-                sudo chmod 600 /home/deploy/.ssh/authorized_keys
-                echo "   - authorized_keys copied"
-              else
-                echo "   - authorized_keys already present"
-              fi
-            EOH
-            say output
-            say "✅ Setup completed", :green
-          end
-
-          def perform_rollback_config(ssh)
-            output = ssh.exec! <<~'EOH'
-              set -e
-
-              echo "🔁 Backing up SSH config…"
-              sudo test -f /etc/ssh/sshd_config.bak || sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak && echo "   - sshd_config backed up"
-
-              echo "✍🏻 Restoring SSH config…"
-              grep -q '^PermitRootLogin yes' /etc/ssh/sshd_config \
-                || sudo sed -i 's/^#*PermitRootLogin .*/PermitRootLogin yes/' /etc/ssh/sshd_config && echo "   - PermitRootLogin yes"
-              grep -q '^PasswordAuthentication yes' /etc/ssh/sshd_config \
-                || sudo sed -i 's/^#*PasswordAuthentication .*/PasswordAuthentication yes/' /etc/ssh/sshd_config && echo "   - PasswordAuthentication yes"
-              sudo systemctl restart sshd && echo "   - sshd restarted"
-            EOH
-            say output
-            say "✅ SSH config restored, closing deploy session", :green
-          end
-
-          def perform_rollback_cleanup(ssh)
-            output = ssh.exec! <<~'EOH'
-              set -e
-
-              echo "✍🏻 Removing sudoers file…"
-              if [ -f /etc/sudoers.d/deploy ]; then
-                sudo rm -f /etc/sudoers.d/deploy && echo "   - /etc/sudoers.d/deploy removed"
-              else
-                echo "   - no sudoers file to remove"
-              fi
-
-              echo "✍🏻 Killing remaining processes for deploy…"
-              if id deploy &>/dev/null; then
-                sudo pkill -u deploy && echo "   - processes killed" || echo "   - no processes found"
-              else
-                echo "   - user 'deploy' does not exist, skipping"
-              fi
-
-              echo "✍🏻 Deleting deploy user…"
-              if id deploy &>/dev/null; then
-                if command -v deluser &>/dev/null; then
-                  sudo deluser --remove-home deploy && echo "   - deploy user removed"
-                else
-                  sudo userdel -r deploy && echo "   - deploy user removed"
-                fi
-              else
-                echo "   - deploy user does not exist"
-              fi
-            EOH
-            say output
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-# 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/commands/switch_env.rb

@@ -1,42 +0,0 @@
-require "thor"
-require "fileutils"
-
-module Kitsune
-  module Kit
-    module Commands
-      class SwitchEnv < Thor
-        namespace "switch_env"
-
-        desc "to ENV_NAME", "Switch active Kitsune Kit environment (development, production, etc)"
-        def to(env_name)
-          kit_env_path = ".kitsune/kit.env"
-          infra_env_path = ".kitsune/infra.#{env_name}.env"
-          blueprint_path = File.expand_path("../../blueprints/.env.template", __dir__)
-
-          unless File.exist?(kit_env_path)
-            say "❌ No .kitsune/kit.env found. Did you run `kitsune kit init`?", :red
-            exit(1)
-          end
-
-          content = File.read(kit_env_path)
-
-          if content.match?(/^KIT_ENV=/)
-            new_content = content.gsub(/^KIT_ENV=.*/, "KIT_ENV=#{env_name}")
-          else
-            new_content = "KIT_ENV=#{env_name}\n" + content
-          end
-
-          File.write(kit_env_path, new_content)
-          say "🎯 Environment switched to '#{env_name}' in .kitsune/kit.env", :green
-
-          unless File.exist?(infra_env_path)
-            FileUtils.cp(blueprint_path, infra_env_path)
-            say "📝 Created new infra environment file: #{infra_env_path}", :cyan
-          else
-            say "📄 Infra environment file already exists: #{infra_env_path}", :green
-          end
-        end
-      end
-    end
-  end
-end

data/lib/kitsune/kit/defaults.rb

@@ -1,91 +0,0 @@
-module Kitsune
-  module Kit
-    module Defaults
-      DROPLET = {
-        droplet_name: "app-dev",
-        region: "sfo3",
-        size: "s-1vcpu-1gb",
-        image: "ubuntu-22-04-x64",
-        tag: "rails-dev"
-      }.freeze
-
-      SSH = {
-        ssh_port: "22",
-        ssh_key_path: "~/.ssh/id_rsa"
-      }.freeze
-
-      POSTGRES = {
-        user: "postgres",
-        password: "secret",
-        port: "5432",
-        image: "postgres:17"
-      }.freeze
-
-      SYSTEM = {
-        swap_size_gb: 2,
-        swap_swappiness: 10,
-        disable_swap: false
-      }.freeze
-
-      METRICS = {
-        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]),
-          region: ENV.fetch('REGION', DROPLET[:region]),
-          size: ENV.fetch('SIZE', DROPLET[:size]),
-          image: ENV.fetch('IMAGE', DROPLET[:image]),
-          tag: ENV.fetch('TAG_NAME', DROPLET[:tag]),
-          ssh_key_id: ENV.fetch('SSH_KEY_ID') { abort "❌ Missing SSH_KEY_ID" }
-        }
-      end
-
-      def self.ssh
-        {
-          ssh_port: ENV.fetch('SSH_PORT', SSH[:ssh_port]),
-          ssh_key_path: ENV.fetch('SSH_KEY_PATH', SSH[:ssh_key_path])
-        }
-      end
-
-      def self.postgres
-        env = ENV.fetch('KIT_ENV', 'development')
-
-        {
-          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]),
-          postgres_image: ENV.fetch('POSTGRES_IMAGE', POSTGRES[:image])
-        }
-      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,
-          swap_swappiness: ENV.fetch("SWAP_SWAPPINESS", SYSTEM[:swap_swappiness]).to_i,
-          disable_swap: ENV.fetch("DISABLE_SWAP", SYSTEM[:disable_swap].to_s) == "true"
-        }
-      end
-
-      def self.metrics
-        {
-          enable_do_metrics: ENV.fetch("ENABLE_DO_METRICS", METRICS[:enable_do_metrics].to_s) == "true"
-        }
-      end
-    end
-  end
-end

data/lib/kitsune/kit/env_loader.rb

@@ -1,41 +0,0 @@
-require "dotenv"
-module Kitsune
-  module Kit
-    class EnvLoader
-      @loaded = false
-
-      def self.load!
-        return if @loaded
-
-        env = ENV["KIT_ENV"] || read_kit_env || "development"
-
-        possible_paths = [
-          ".kitsune/infra.#{env}.env",
-          ".kitsune/infra.env"
-        ]
-
-        found = possible_paths.find { |path| File.exist?(path) }
-
-        if found
-          Dotenv.load(found)
-          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
-
-        @loaded = true
-      end
-
-      def self.read_kit_env
-        path = ".kitsune/kit.env"
-        if File.exist?(path)
-          vars = Dotenv.parse(path)
-          vars["KIT_ENV"]
-        else
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/kitsune/kit/options_builder.rb

@@ -1,26 +0,0 @@
-module Kitsune
-  module Kit
-    class OptionsBuilder
-      def self.build(current_options, required: [], defaults: {})
-        current = current_options.transform_keys(&:to_sym)
-
-        filled = defaults.dup
-
-        defaults.keys.each do |key|
-          env_key = key.to_s.upcase
-          filled[key] = ENV[env_key] if ENV[env_key]
-        end
-
-        filled.merge!(current)
-
-        missing = required.select { |key| filled[key].nil? }
-
-        unless missing.empty?
-          abort "❌ Missing required options: #{missing.join(', ')}"
-        end
-
-        filled
-      end
-    end
-  end
-end

data/lib/kitsune/kit/provisioner.rb

@@ -1,107 +0,0 @@
-require "droplet_kit"
-
-module Kitsune
-  module Kit
-    class Provisioner
-      def initialize(opts)
-        @droplet_name = opts[:droplet_name]
-        @region       = opts[:region]
-        @size         = opts[:size]
-        @image        = opts[:image]
-        @tag          = opts[:tag]
-        @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
-  
-      # Find an existing droplet by name
-      def find_droplet
-        @client.droplets.all(tag_name: @tag).detect { |d| d.name == @droplet_name }
-      end
-  
-      # Create command: shows if it exists or creates a new one
-      def create_or_show
-        if (d = find_droplet)
-          ip = public_ip(d)
-          puts "✅ Droplet '#{@droplet_name}' already exists (ID: #{d.id}, IP: #{ip})"
-        else
-          puts "✍🏻 Creating Droplet '#{@droplet_name}'..."
-          spec = DropletKit::Droplet.new(
-            name:       @droplet_name,
-            region:     @region,
-            size:       @size,
-            image:      @image,
-            ssh_keys:   [@ssh_key_id],
-            tags:       [@tag]
-          )
-          created = @client.droplets.create(spec)
-          wait_for_status(created.id)
-          ip = wait_for_public_ip(created.id)
-
-          wait_for_ssh(ip)
-  
-          puts "✅ Droplet created: ID=#{created.id}, IP=#{ip}"
-        end
-      end
-  
-      # Rollback command: deletes it if it exists
-      def rollback
-        if (d = find_droplet)
-          puts "🔁 Deleting Droplet '#{@droplet_name}' (ID: #{d.id})..."
-          @client.droplets.delete(id: d.id)
-          puts "✅ Droplet deleted 💥"
-        else
-          puts "✅ Nothing to delete: '#{@droplet_name}' does not exist"
-        end
-      end
-  
-      private
-  
-      # Extracts the public IP from a DropletKit::Droplet
-      def public_ip(droplet)
-        v4 = droplet.networks.v4.find { |n| n.type == "public" }
-        v4 ? v4.ip_address : "(no public IP yet)"
-      end
-
-      # Waits until the droplet reaches the 'active' status
-      def wait_for_status(droplet_id, interval: 5, max_attempts: 24)
-        max_attempts.times do |i|
-          droplet = @client.droplets.find(id: droplet_id)
-          estado = droplet.status
-          puts "⏳ Droplet status: #{estado} (#{i + 1}/#{max_attempts})"
-          return if estado == "active"
-          sleep interval
-        end
-        abort "❌ Timeout: the Droplet did not reach 'active' status after #{interval * max_attempts} seconds"
-      end
-
-      # Waits until obtaining the public IP
-      def wait_for_public_ip(droplet_id, interval: 5, max_attempts: 24)
-        max_attempts.times do |i|
-          droplet = @client.droplets.find(id: droplet_id)
-          if (v4 = droplet.networks.v4.find { |n| n.type == "public" })
-            return v4.ip_address
-          end
-          puts "⏳ Waiting for public IP... (#{i + 1}/#{max_attempts})"
-          sleep interval
-        end
-        abort "❌ Timeout: the Droplet did not obtain a public IP after #{interval * max_attempts} seconds"
-      end
-
-      # Waits for the SSH port to become accessible
-      def wait_for_ssh(ip, interval: 5, max_attempts: 24)
-        max_attempts.times do |i|
-          begin
-            puts "🔐 Waiting for SSH connection to #{ip}... (#{i + 1}/#{max_attempts})"
-            TCPSocket.new(ip, 22).close
-            puts "🔓 SSH connection to #{ip} established"
-            return
-          rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError
-            sleep interval
-          end
-        end
-        abort "❌ Could not connect via SSH to #{ip} after #{interval * max_attempts} seconds"
-      end
-    end
-  end
-end

data/sig/kitsune/kit.rbs

@@ -1,6 +0,0 @@
-module Kitsune
-  module Kit
-    VERSION: String
-    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-  end
-end