stable-cli-rails 0.6.9 → 0.7.11

data/lib/stable/services/caddy_manager.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class CaddyManager
+      class << self
+        def caddyfile
+          Stable::Paths.caddyfile
+        end
+
+        def remove(domain)
+          return unless File.exist?(caddyfile)
+
+          content = File.read(caddyfile)
+          content = remove_domain_block(content, domain)
+
+          atomic_write(caddyfile, content)
+          system("caddy fmt --overwrite #{caddyfile}")
+
+          reload_if_running
+        end
+
+        def add_app(name, skip_ssl: false)
+          app = Services::AppRegistry.all.find { |a| a[:name] == name }
+          return unless app
+
+          domain = app[:domain]
+          port   = app[:port]
+
+          ensure_certs_dir! unless skip_ssl
+          ensure_cert_for!(domain) unless skip_ssl
+
+          FileUtils.touch(caddyfile)
+          content = File.read(caddyfile)
+
+          content = remove_domain_block(content, domain)
+          content << build_block(domain, port, skip_ssl: skip_ssl)
+
+          atomic_write(caddyfile, content)
+          system("caddy fmt --overwrite #{caddyfile}")
+
+          ensure_running!
+        end
+
+        def reload
+          if system('which caddy > /dev/null')
+            pid = Process.spawn("caddy reload --config #{caddyfile}")
+            Process.detach(pid.to_i)
+          else
+            puts 'Caddy not found. Install Caddy first.'
+          end
+        end
+
+        def ensure_running!
+          if running?
+            reload
+          else
+            system("caddy run --config #{caddyfile} --adapter caddyfile &")
+            sleep 2
+          end
+        end
+
+        def reload_if_running
+          reload if running?
+        end
+
+        def running?
+          require 'socket'
+          TCPSocket.new('127.0.0.1', 2019).close
+          true
+        rescue Errno::ECONNREFUSED
+          false
+        end
+
+        private
+
+        def ensure_cert_for!(domain)
+          cert_path = File.join(Stable::Paths.certs_dir, "#{domain}.pem")
+          key_path  = File.join(Stable::Paths.certs_dir, "#{domain}-key.pem")
+
+          return if valid_pem?(cert_path) && valid_pem?(key_path)
+
+          raise 'mkcert not installed' unless system('which mkcert > /dev/null')
+
+          System::Shell.run(
+            "mkcert -cert-file #{cert_path} -key-file #{key_path} #{domain}"
+          )
+
+          wait_for_pem!(cert_path)
+          wait_for_pem!(key_path)
+        end
+
+        def build_block(domain, port, skip_ssl: false)
+          cert_path = File.join(Stable::Paths.certs_dir, "#{domain}.pem") unless skip_ssl
+          key_path  = File.join(Stable::Paths.certs_dir, "#{domain}-key.pem") unless skip_ssl
+          prefix = skip_ssl ? 'http' : 'https'
+          certs = skip_ssl ? '' : "tls #{cert_path} #{key_path}"
+          <<~CADDY
+
+            #{prefix}://#{domain} {
+                reverse_proxy 127.0.0.1:#{port}
+                #{certs}
+            }
+          CADDY
+        end
+
+        def remove_domain_block(content, domain)
+          regex = %r{
+            (https?|http)://#{Regexp.escape(domain)}\s*\{
+            .*?
+            \}
+          }mx
+
+          content.gsub(regex, '')
+        end
+
+        def atomic_write(path, content)
+          tmp = "#{path}.tmp"
+          File.write(tmp, content)
+          File.rename(tmp, path)
+        end
+
+        def valid_pem?(path)
+          File.exist?(path) &&
+            File.size?(path) &&
+            File.read(path, 64).include?('BEGIN')
+        end
+
+        def wait_for_pem!(path, timeout: 3)
+          start = Time.now
+
+          until valid_pem?(path)
+            raise "Invalid PEM file: #{path}" if Time.now - start > timeout
+
+            sleep 0.1
+          end
+        end
+
+        def ensure_certs_dir!
+          certs_dir = Stable::Paths.certs_dir
+          FileUtils.mkdir_p(certs_dir)
+
+          begin
+            FileUtils.chown_R(Etc.getlogin, nil, certs_dir)
+          rescue StandardError
+            nil
+          end
+
+          Dir.glob("#{certs_dir}/*.pem").each do |pem|
+            mode = pem.end_with?('-key.pem') ? 0o600 : 0o644
+            begin
+              FileUtils.chmod(mode, pem)
+            rescue StandardError
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/database/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    module Database
+      class Base
+        def initialize(app_name:, app_path:)
+          @app_name = app_name
+          @app_path = app_path
+          @database_name = @app_name
+                           .downcase
+                           .gsub(/[^a-z0-9_]/, '_')
+                           .gsub(/_+/, '_')
+                           .gsub(/^_+|_+$/, '')
+        end
+
+        def prepare
+          System::Shell.run(
+            "cd #{@app_path} && bundle exec rails db:prepare"
+          )
+        end
+
+        protected
+
+        def write_database_yml(creds)
+          config = {
+            'default' => base_config(creds),
+            'development' => base_config(creds),
+            'test' => base_config(creds).merge(
+              'database' => "#{@database_name}_test"
+            ),
+            'production' => base_config(creds).merge(
+              'database' => "#{@database_name}_production"
+            )
+          }
+
+          path = File.join(@app_path, 'config/database.yml')
+          File.write(path, config.to_yaml)
+        end
+
+        def base_config(_creds)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/database/mysql.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    module Database
+      class MySQL < Base
+        def setup
+          creds = Stable::Utils::Prompts.mysql_root_credentials
+          create_database(creds)
+          write_database_yml(creds)
+          prepare
+        end
+
+        def create_database(creds)
+          System::Shell.run(
+            "mysql -u #{creds[:user]} -p#{creds[:password]} -e 'CREATE DATABASE IF NOT EXISTS #{@database_name};'"
+          )
+        end
+
+        protected
+
+        def base_config(creds)
+          {
+            'adapter' => 'mysql2',
+            'encoding' => 'utf8mb4',
+            'pool' => 5,
+            'database' => @database_name,
+            'username' => creds[:user],
+            'password' => creds[:password],
+            'host' => 'localhost'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/database/postgres.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    module Database
+      class Postgres < Base
+        def setup
+          System::Shell.run("createdb #{@database_name}")
+          prepare
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/dependency_checker.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class DependencyChecker
+      def run
+        [
+          check('Homebrew', 'brew'),
+          check('Caddy', 'caddy'),
+          check('mkcert', 'mkcert'),
+          check('RVM', 'rvm'),
+          check_caddy_running,
+          check_certs_dir,
+          check_apps_registry
+        ]
+      end
+
+      private
+
+      def check(name, command)
+        ok = system("which #{command} > /dev/null 2>&1")
+        {
+          name: name,
+          ok: ok,
+          message: ok ? nil : "#{name} not found in PATH"
+        }
+      end
+
+      def check_caddy_running
+        ok = system('pgrep caddy > /dev/null 2>&1')
+        {
+          name: 'Caddy running',
+          ok: ok,
+          message: ok ? nil : 'Caddy is installed but not running'
+        }
+      end
+
+      def check_certs_dir
+        path = File.expand_path('~/StableCaddy/certs')
+        ok = Dir.exist?(path)
+        {
+          name: 'Certificates directory',
+          ok: ok,
+          message: ok ? nil : "Missing #{path}. Run `stable setup`"
+        }
+      end
+
+      def check_apps_registry
+        path = File.expand_path('~/StableCaddy/apps.yml')
+        ok = File.exist?(path)
+        {
+          name: 'Apps registry',
+          ok: ok,
+          message: ok ? nil : 'Missing apps registry. Run `stable setup`'
+        }
+      end
+    end
+  end
+end

data/lib/stable/services/hosts_manager.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class HostsManager
+      HOSTS_FILE = '/etc/hosts'
+
+      def self.remove(domain)
+        lines = File.read(HOSTS_FILE).lines
+        filtered = lines.reject { |l| l.include?(domain) }
+
+        return if lines == filtered
+
+        File.write('/tmp/hosts', filtered.join)
+        system("sudo mv /tmp/hosts #{HOSTS_FILE}")
+      end
+
+      def self.add(domain)
+        entry = "127.0.0.1\t#{domain}\n"
+        hosts = File.read(HOSTS_FILE)
+        return if hosts.include?(domain)
+
+        if Process.uid.zero?
+          File.open(HOSTS_FILE, 'a') { |f| f.puts entry }
+        else
+          system(%(echo "#{entry}" | sudo tee -a #{HOSTS_FILE} > /dev/null))
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/process_manager.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class ProcessManager
+      def self.start(target)
+        app = target.is_a?(String) ? AppRegistry.fetch(target) : target
+
+        path = app[:path]
+        port = app[:port]
+
+        ruby = app[:ruby]
+        gemset = Stable::Services::Ruby.gemset_for(app)
+
+        if ruby && gemset
+          Stable::Services::Ruby.ensure_rvm!
+          system("bash -lc 'rvm #{ruby}@#{gemset} --create do true'")
+          rvm_cmd = "rvm #{ruby}@#{gemset} do"
+        elsif ruby
+          rvm_cmd = "rvm #{ruby} do"
+        else
+          rvm_cmd = nil
+        end
+
+        log_file = File.join(path, 'log', 'stable.log')
+        FileUtils.mkdir_p(File.dirname(log_file))
+
+        cmd = if rvm_cmd
+                "cd \"#{path}\" && #{rvm_cmd} bundle exec rails s -p #{port} -b 127.0.0.1"
+              else
+                "cd \"#{path}\" && bundle exec rails s -p #{port} -b 127.0.0.1"
+              end
+
+        pid = spawn('bash', '-lc', cmd, out: log_file, err: log_file)
+
+        Process.detach(pid)
+
+        AppRegistry.update(app[:name], started_at: Time.now.to_i, pid: pid)
+
+        pid
+      end
+
+      def self.stop(app)
+        pid = app[:pid]
+        return unless pid
+
+        output = `lsof -i tcp:#{app[:port]} -t`.strip
+        if output.empty?
+          puts "No app running on port #{app[:port]}"
+        else
+          output.split("\n").each { |pid| Process.kill('TERM', pid.to_i) }
+          puts "Stopped #{app[:name]} on port #{app[:port]}"
+        end
+
+        AppRegistry.update(app[:name], started_at: nil, pid: nil)
+      rescue Errno::ESRCH
+        AppRegistry.update(app[:name], started_at: nil, pid: nil)
+      end
+    end
+  end
+end

data/lib/stable/services/ruby.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    module Ruby
+      def self.ensure_version(version)
+        return if version.nil? || version.to_s.strip.empty?
+
+        # Check if version exists via rvm
+        installed = system("bash -lc 'rvm list strings | grep -q #{version}'")
+        return if installed
+
+        puts "Installing Ruby #{version}..."
+        success = system("bash -lc 'rvm install #{version}'")
+        raise "Failed to install Ruby #{version}" unless success
+      end
+
+      def self.rvm_available?
+        system("bash -lc 'command -v rvm > /dev/null'")
+      end
+
+      def self.rbenv_available?
+        system('command -v rbenv > /dev/null')
+      end
+
+      def self.ensure_rvm!
+        return if rvm_available?
+
+        puts 'RVM not found. Installing RVM...'
+
+        install_cmd = <<~CMD
+          curl -sSL https://get.rvm.io | bash -s stable
+        CMD
+
+        abort 'RVM installation failed' unless system(install_cmd)
+
+        rvm_script = File.expand_path('~/.rvm/scripts/rvm')
+        abort 'RVM installed but could not be loaded' unless File.exist?(rvm_script)
+
+        ENV['PATH'] = "#{File.expand_path('~/.rvm/bin')}:#{ENV.fetch('PATH', nil)}"
+
+        system(%(bash -lc "source #{rvm_script} && rvm --version")) || abort('RVM installed but not functional')
+      end
+
+      def self.ensure_ruby_installed!(version)
+        return if system("rvm list strings | grep ruby-#{version} > /dev/null")
+
+        puts "Installing Ruby #{version}..."
+        system("rvm install #{version}") || abort("Failed to install Ruby #{version}")
+      end
+
+      def self.ensure_rvm_ruby!(version)
+        system("bash -lc 'rvm list strings | grep -q #{version} || rvm install #{version}'")
+      end
+
+      def self.ensure_rbenv_ruby!(version)
+        system("rbenv versions | grep -q #{version} || rbenv install #{version}")
+      end
+
+      def self.rvm_script
+        File.expand_path('~/.rvm/scripts/rvm')
+      end
+
+      # Return a command prefix that sources RVM and executes the given ruby@gemset
+      # Example: "source /Users/me/.rvm/scripts/rvm && rvm 3.4.4@myapp do"
+      def self.rvm_prefix(ruby, gemset = nil)
+        gemset_part = gemset ? "@#{gemset}" : ''
+        "source #{rvm_script} && rvm #{ruby}#{gemset_part} do"
+      end
+
+      def self.detect_ruby_version(path)
+        rv = File.join(path, '.ruby-version')
+        return File.read(rv).strip if File.exist?(rv)
+
+        gemfile = File.join(path, 'Gemfile')
+        if File.exist?(gemfile)
+          ruby_line = File.read(gemfile)[/^ruby ['"](.+?)['"]/, 1]
+          return ruby_line if ruby_line
+        end
+
+        nil
+      end
+
+      def self.gemset_for(app)
+        gemset_file = File.join(app[:path], '.ruby-gemset')
+        return File.read(gemset_file).strip if File.exist?(gemset_file)
+
+        nil
+      end
+
+      def self.rvm_exec(app, ruby)
+        gemset = gemset_for(app)
+
+        if gemset
+          "rvm #{ruby}@#{gemset} do"
+        else
+          "rvm #{ruby} do"
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/setup_runner.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class SetupRunner
+      def call
+        ensure_directories
+        ensure_apps_registry
+        ensure_caddyfile
+        # start or ensure caddy is running like original CLI
+        Stable::Services::CaddyManager.ensure_running!
+        puts "Caddy home initialized at #{Stable::Paths.root}"
+        self.class.ensure_dependencies!
+      end
+
+      def self.ensure_dependencies!
+        new.send(:ensure_dependencies!)
+      end
+
+      private
+
+      def ensure_directories
+        path = Stable::Paths.certs_dir
+        FileUtils.mkdir_p(path)
+      end
+
+      def ensure_apps_registry
+        path = Stable::Paths.apps_file
+        File.write(path, {}.to_yaml) unless File.exist?(path)
+      end
+
+      def ensure_caddyfile
+        path = Stable::Paths.caddyfile
+        return if File.exist?(path)
+
+        File.write(path, <<~CADDY)
+          {
+            auto_https off
+          }
+        CADDY
+      end
+
+      def ensure_dependencies!
+        unless system('which brew > /dev/null')
+          puts 'Homebrew is required. Install it first: https://brew.sh'
+          exit 1
+        end
+
+        # --- Install Caddy ---
+        unless system('which caddy > /dev/null')
+          puts 'Installing Caddy...'
+          system('brew install caddy')
+        end
+
+        # --- Install mkcert ---
+        unless system('which mkcert > /dev/null')
+          puts 'Installing mkcert...'
+          system('brew install mkcert nss')
+        end
+
+        # Always ensure mkcert CA is installed
+        system('mkcert -install')
+
+        # --- Install PostgreSQL ---
+        unless system('which psql > /dev/null')
+          puts 'Installing PostgreSQL...'
+          system('brew install postgresql')
+          system('brew services start postgresql')
+        end
+
+        # --- Install MySQL ---
+        unless system('which mysql > /dev/null')
+          puts 'Installing MySQL...'
+          system('brew install mysql')
+          system('brew services start mysql')
+        end
+
+        puts '✅ All dependencies are installed and running.'
+      end
+    end
+  end
+end

data/lib/stable/system/shell.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Stable
+  module System
+    class Shell
+      def self.run(cmd)
+        puts "→ #{cmd}"
+        success = system(cmd)
+        raise "Command failed: #{cmd}" unless success
+      end
+    end
+  end
+end

data/lib/stable/utils/prompts.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+module Stable
+  module Utils
+    class Prompts
+      def self.mysql_root_credentials
+        print 'Enter MySQL root username (default: root): '
+        user = $stdin.gets.strip
+        user = 'root' if user.empty?
+
+        print 'Enter MySQL root password (leave blank if none): '
+        password = $stdin.noecho(&:gets).chomp
+        puts
+
+        { user: user, password: password }
+      end
+    end
+  end
+end

data/lib/stable/validators/app_name.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Stable
+  module Validators
+    class AppName
+      VALID_PATTERN = /\A[a-z0-9]+(-[a-z0-9]+)*\z/
+      MAX_LENGTH = 63
+
+      def self.call!(name)
+        normalized = normalize(name)
+
+        unless valid?(normalized)
+          raise Thor::Error, <<~MSG
+            Invalid app name: "#{name}"
+
+            Use only:
+              - lowercase letters (a-z)
+              - numbers (0-9)
+              - hyphens (-)
+
+            Rules:
+              - no spaces or underscores
+              - cannot start or end with a hyphen
+              - max #{MAX_LENGTH} characters
+
+            Example:
+              stable new my-app
+          MSG
+        end
+
+        normalized
+      end
+
+      def self.normalize(name)
+        name
+          .downcase
+          .strip
+          .gsub(/\s+/, '-') # spaces → hyphens
+          .gsub(/[^a-z0-9-]/, '') # drop invalid chars
+          .gsub(/-+/, '-')        # collapse hyphens
+          .gsub(/\A-|-+\z/, '')   # trim hyphens
+      end
+
+      def self.valid?(name)
+        name.length <= MAX_LENGTH && VALID_PATTERN.match?(name)
+      end
+    end
+  end
+end