stable-cli-rails 0.6.9 → 0.7.11

data/lib/stable/commands/doctor.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    class Doctor
+      def call
+        puts 'Running Stable health checks...'
+        puts
+
+        checks = Services::DependencyChecker.new.run
+
+        checks.each do |check|
+          print_check(check)
+        end
+
+        puts
+        summary(checks)
+      end
+
+      private
+
+      def print_check(check)
+        icon = check[:ok] ? '✔' : '✖'
+        puts "#{icon} #{check[:name]}"
+        puts "    #{check[:message]}" unless check[:ok]
+      end
+
+      def summary(checks)
+        failures = checks.count { |c| !c[:ok] }
+
+        if failures.zero?
+          puts 'All checks passed.'
+        else
+          puts "#{failures} issue(s) detected. Fix the above and re-run `stable doctor`."
+        end
+      end
+    end
+  end
+end

data/lib/stable/commands/list.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    class List
+      def call
+        apps = Services::AppRegistry.all
+
+        if apps.empty?
+          puts 'No apps registered.'
+          return
+        end
+
+        print_header
+
+        apps.each do |app|
+          puts format_row(app)
+        end
+      end
+
+      private
+
+      def print_header
+        puts 'APP                DOMAIN                     PORT     RUBY       STATUS    '
+        puts '-' * 78
+      end
+
+      def format_row(app)
+        status =
+          if app[:started_at]
+            'running'
+          else
+            'stopped'
+          end
+
+        format(
+          '%-18s %-26s %-8s %-10s %-10s',
+          app[:name],
+          app[:domain],
+          app[:port],
+          app[:ruby],
+          status
+        )
+      end
+    end
+  end
+end

data/lib/stable/commands/new.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    class New
+      def initialize(name, options)
+        @name = name
+        @options = options
+      end
+
+      def call
+        Services::AppCreator.new(@name, @options).call
+      end
+    end
+  end
+end

data/lib/stable/commands/remove.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    class Remove
+      def initialize(name)
+        @name = name
+      end
+
+      def call
+        app = Services::AppRegistry.find(@name)
+        abort 'App not found' unless app
+
+        Services::ProcessManager.stop(app)
+        Services::HostsManager.remove(app[:domain])
+        Services::CaddyManager.remove(app[:domain])
+        Services::AppRegistry.remove(@name)
+        Services::CaddyManager.reload
+
+        puts "Removed #{@name}"
+      end
+    end
+  end
+end

data/lib/stable/commands/restart.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    class Restart
+      def initialize(name)
+        @name = name
+      end
+
+      def call
+        Services::AppRestarter.new(@name).call
+      end
+    end
+  end
+end

data/lib/stable/commands/setup.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    class Setup
+      def call
+        Services::SetupRunner.new.call
+      end
+    end
+  end
+end

data/lib/stable/commands/start.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    class Start
+      def initialize(name)
+        @name = name
+      end
+
+      def call
+        Services::AppStarter.new(@name).call
+      end
+    end
+  end
+end

data/lib/stable/commands/stop.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    class Stop
+      def initialize(name)
+        @name = name
+      end
+
+      def call
+        Services::AppStopper.new(@name).call
+      end
+    end
+  end
+end

data/lib/stable/config/paths.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Stable
+  module Config
+    APP_ROOT = File.expand_path('~/StableCaddy')
+    CADDYFILE = File.join(APP_ROOT, 'Caddyfile')
+    REGISTRY = File.join(APP_ROOT, 'apps.yml')
+  end
+end

data/lib/stable/registry.rb

@@ -6,7 +6,7 @@ require 'fileutils'
 module Stable
   class Registry
     def self.file_path
-      File.join(Stable.root, 'apps.yml')
+      Stable::Paths.apps_file
     end
 
     def self.save(apps)
@@ -15,7 +15,17 @@ module Stable
     end
 
     def self.apps
-      File.exist?(file_path) ? YAML.load_file(file_path) : []
+      return [] unless File.exist?(file_path)
+
+      data = YAML.load_file(file_path) || []
+      data.map do |entry|
+        next entry unless entry.is_a?(Hash)
+
+        entry.each_with_object({}) do |(k, v), memo|
+          key = k.is_a?(String) ? k.to_sym : k
+          memo[key] = v
+        end
+      end
     end
   end
 end

data/lib/stable/services/app_creator.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class AppCreator
+      def initialize(name, options)
+        @name = name
+        @options = options
+      end
+
+      def call
+        ruby = @options[:ruby] || RUBY_VERSION
+        port = @options[:port] || next_free_port
+        app_path = File.expand_path(@name)
+        domain = "#{@name}.test"
+
+        # --- Register app in registry ---
+        Services::AppRegistry.add(name: @name, path: app_path, domain: domain, port: port, ruby: ruby, started_at: nil,
+                                  pid: nil)
+
+        abort "Folder already exists: #{app_path}" if File.exist?(app_path)
+
+        # --- Ensure Ruby + gemset ---
+        Ruby.ensure_version(ruby)
+        Ruby.ensure_rvm!
+        System::Shell.run("bash -lc 'source #{Ruby.rvm_script} && rvm #{ruby}@#{@name} --create do true'")
+
+        rvm_cmd = Ruby.rvm_prefix(ruby, @name)
+
+        # --- Install Rails into gemset if missing ---
+        rails_version = @options[:rails]
+        rails_check_cmd = if rails_version
+                            "#{rvm_cmd} gem list -i rails -v #{rails_version}"
+                          else
+                            "#{rvm_cmd} gem list -i rails"
+                          end
+
+        unless system("bash -lc '#{rails_check_cmd}'")
+          puts "Installing Rails #{rails_version || 'latest'} in gemset..."
+          install_cmd = rails_version ? "#{rvm_cmd} gem install rails -v #{rails_version}" : "#{rvm_cmd} gem install rails"
+          system("bash -lc '#{install_cmd}'") or abort('Failed to install Rails')
+        end
+
+        # --- Create Rails app ---
+        puts "Creating Rails app #{@name} (Ruby #{ruby})..."
+        System::Shell.run("bash -lc '#{rvm_cmd} rails new #{app_path}'")
+
+        # --- Write ruby version/gemset and bundle install inside gemset ---
+        Dir.chdir(app_path) do
+          File.write('.ruby-version', "#{ruby}\n")
+          File.write('.ruby-gemset', "#{@name}\n")
+
+          puts 'Running bundle install...'
+          System::Shell.run("bash -lc '#{rvm_cmd} bundle install --jobs=4 --retry=3'")
+        end
+
+        # --- Database integration ---
+        if @options[:db]
+          adapter = if @options[:mysql]
+                      :mysql
+                    else
+                      :postgresql
+                    end
+
+          gem_name = adapter == :postgresql ? 'pg' : 'mysql2'
+          gemfile_path = File.join(app_path, 'Gemfile')
+          unless File.read(gemfile_path).include?(gem_name)
+            File.open(gemfile_path, 'a') do |f|
+              f.puts "\n# Added by Stable CLI"
+              f.puts "gem '#{gem_name}'"
+            end
+            puts "✅ Added '#{gem_name}' gem to Gemfile"
+          end
+
+          # ensure gem is installed inside gemset
+          System::Shell.run("bash -lc 'cd #{app_path} && #{rvm_cmd} bundle install --jobs=4 --retry=3'")
+
+          # run adapter setup which will write database.yml and prepare
+          db_adapter = adapter == :mysql ? Database::MySQL : Database::Postgres
+          db_adapter.new(app_name: @name, app_path: app_path).setup
+        end
+
+        # --- Refresh bundle and prepare DB (idempotent) ---
+        System::Shell.run("bash -lc 'cd #{app_path} && #{rvm_cmd} bundle check || #{rvm_cmd} bundle install'")
+        System::Shell.run("bash -lc 'cd #{app_path} && #{rvm_cmd} bundle exec rails db:prepare'")
+
+        # --- Hosts, certs, caddy ---
+        Services::HostsManager.add(domain)
+        Services::CaddyManager.add_app(@name, skip_ssl: @options[:skip_ssl])
+        Services::CaddyManager.ensure_running!
+        Services::CaddyManager.reload
+
+        # --- Start the app ---
+        puts "Starting Rails server for #{@name} on port #{port}..."
+        log_file = File.join(app_path, 'log', 'stable.log')
+        FileUtils.mkdir_p(File.dirname(log_file))
+
+        abort "Port #{port} is already in use. Choose another port." if port_in_use?(port)
+
+        pid = spawn('bash', '-lc', "cd \"#{app_path}\" && #{rvm_cmd} bundle exec rails s -p #{port} -b 127.0.0.1",
+                    out: log_file, err: log_file)
+        Process.detach(pid)
+
+        AppRegistry.update(@name, started_at: Time.now.to_i, pid: pid)
+
+        sleep 1.5
+        wait_for_port(port)
+        prefix = @options[:skip_ssl] ? 'http' : 'https'
+        display_domain = if @options[:skip_ssl]
+                           "#{domain}:#{port}"
+                         else
+                           domain
+                         end
+
+        puts "✔ #{@name} running at #{prefix}://#{display_domain}"
+      end
+
+      private
+
+      def create_rails_app
+        System::Shell.run("rails new #{@name}")
+      end
+
+      def setup_database
+        return unless @options[:mysql] || @options[:postgres]
+
+        adapter =
+          if @options[:mysql]
+            Database::MySQL
+          else
+            Database::Postgres
+          end
+
+        adapter.new(@name).setup
+      end
+
+      def next_free_port
+        used_ports = Services::AppRegistry.all.map { |a| a[:port] }
+        port = 3000
+        port += 1 while used_ports.include?(port) || port_in_use?(port)
+        port
+      end
+
+      def port_in_use?(port)
+        system("lsof -i tcp:#{port} > /dev/null 2>&1")
+      end
+
+      def wait_for_port(port, timeout: 20)
+        require 'socket'
+        start = Time.now
+
+        loop do
+          TCPSocket.new('127.0.0.1', port).close
+          return
+        rescue Errno::ECONNREFUSED
+          raise "Rails never bound port #{port}. Check log/stable.log" if Time.now - start > timeout
+
+          sleep 0.5
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/app_registry.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class AppRegistry
+      class << self
+        def all
+          Stable::Registry.apps
+        end
+
+        def find(name)
+          Stable::Registry.apps.find { |a| a[:name] == name }
+        end
+
+        def fetch(name)
+          app = find(name)
+          abort("No app found with name #{name}") unless app
+          app
+        end
+
+        # Register a new app by name. If the folder already exists in the current
+        # working directory it will use that path. Port is allocated sequentially.
+        def register(name)
+          path = File.expand_path(name)
+          domain = "#{name}.test"
+
+          used_ports = Stable::Registry.apps.map { |a| a[:port] }.compact
+          port = (used_ports.max || 2999) + 1
+
+          app = {
+            name: name,
+            path: path,
+            domain: domain,
+            port: port,
+            ruby: nil,
+            started_at: nil,
+            pid: nil
+          }
+
+          add(app)
+          app
+        end
+
+        def add(app)
+          apps = Stable::Registry.apps
+          apps.reject! { |a| a[:name] == app[:name] }
+          apps << app
+          Stable::Registry.save(apps)
+        end
+
+        # Remove duplicate app entries (by name) and persist the canonical list
+        def dedupe
+          apps = Stable::Registry.apps
+          apps.uniq! { |a| a[:name] }
+          Stable::Registry.save(apps)
+          apps
+        end
+
+        def remove(name)
+          apps = Stable::Registry.apps.reject { |a| a[:name] == name }
+          Stable::Registry.save(apps)
+        end
+
+        def update(name, attrs)
+          apps = Stable::Registry.apps
+          idx = apps.index { |a| a[:name] == name }
+          return unless idx
+
+          apps[idx] = apps[idx].merge(attrs)
+          Stable::Registry.save(apps)
+        end
+
+        def mark_stopped(name)
+          update(name, started_at: nil, pid: nil)
+        end
+
+        alias register_app register
+        alias add_app add
+      end
+    end
+  end
+end
+
+module Stable
+  AppRegistry = Services::AppRegistry
+end

data/lib/stable/services/app_remover.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class AppRemover
+      def initialize(name)
+        @name = name
+      end
+
+      def call
+        app = AppRegistry.fetch(@name)
+        ProcessManager.stop(app)
+        HostsManager.remove(app[:domain])
+        CaddyManager.remove(app[:domain])
+        AppRegistry.remove(@name)
+        CaddyManager.reload
+        puts "✔ #{@name} removed"
+      end
+    end
+  end
+end

data/lib/stable/services/app_restarter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class AppRestarter
+      def initialize(name)
+        @name = name
+      end
+
+      def call
+        app = Services::AppRegistry.find(@name)
+        unless app
+          puts("No app found with name #{@name}")
+          return
+        end
+
+        # Stop if running
+        if app[:pid]
+          begin
+            Process.kill('TERM', app[:pid].to_i)
+          rescue Errno::ESRCH
+            # already dead
+          end
+          AppRegistry.update(@name, started_at: nil, pid: nil)
+          puts "✔ #{@name} stopped"
+        end
+
+        Services::AppStarter.new(@name).call
+      end
+    end
+  end
+end

data/lib/stable/services/app_starter.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class AppStarter
+      def initialize(name)
+        @name = name
+      end
+
+      def call
+        app = Services::AppRegistry.find(@name)
+        unless app
+          puts("No app found with name #{@name}")
+          return
+        end
+
+        port = app[:port] || next_free_port
+        ruby = app[:ruby]
+        path = app[:path]
+
+        if app_running?(app)
+          puts "#{@name} is already running on https://#{app[:domain]} (port #{port})"
+          return
+        end
+
+        gemset = Stable::Services::Ruby.gemset_for(app)
+
+        rvm_cmd =
+          if ruby && gemset
+            System::Shell.run("bash -lc 'source #{Stable::Services::Ruby.rvm_script} && rvm #{ruby}@#{gemset} --create do true'")
+            Stable::Services::Ruby.rvm_prefix(ruby, gemset)
+          elsif ruby
+            Stable::Services::Ruby.rvm_prefix(ruby, nil)
+          end
+
+        puts "Starting #{@name} on port #{port}..."
+
+        log_file = File.join(path, 'log', 'stable.log')
+        FileUtils.mkdir_p(File.dirname(log_file))
+
+        pid = spawn(
+          'bash',
+          '-lc',
+          "cd \"#{path}\" && #{rvm_cmd} bundle exec rails s -p #{port} -b 127.0.0.1",
+          out: log_file,
+          err: log_file
+        ).to_i
+
+        Process.detach(pid)
+
+        wait_for_port(port, timeout: 30)
+
+        AppRegistry.update(app[:name], started_at: Time.now.to_i, pid: pid)
+
+        Stable::Services::CaddyManager.add_app(app[:name], skip_ssl: false)
+        Stable::Services::CaddyManager.reload
+
+        puts "#{@name} started on https://#{app[:domain]}"
+      end
+
+      private
+
+      def next_free_port
+        used_ports = Services::AppRegistry.all.map { |a| a[:port] }
+        port = 3000
+        port += 1 while used_ports.include?(port) || port_in_use?(port)
+        port
+      end
+
+      def port_in_use?(port)
+        system("lsof -i tcp:#{port} > /dev/null 2>&1")
+      end
+
+      def wait_for_port(port, timeout: 20)
+        require 'socket'
+        start = Time.now
+
+        loop do
+          TCPSocket.new('127.0.0.1', port).close
+          return
+        rescue Errno::ECONNREFUSED
+          raise "Rails never bound port #{port}. Check log/stable.log" if Time.now - start > timeout
+
+          sleep 0.5
+        end
+      end
+
+      def app_running?(app)
+        return false unless app && app[:port]
+
+        system("lsof -i tcp:#{app[:port]} -sTCP:LISTEN > /dev/null 2>&1")
+      end
+    end
+  end
+end

data/lib/stable/services/app_stopper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    class AppStopper
+      def initialize(name)
+        @app = AppRegistry.fetch(name)
+      end
+
+      def call
+        ProcessManager.stop(@app)
+        AppRegistry.mark_stopped(@app[:name])
+        puts "✔ #{@app[:name]} stopped"
+      end
+    end
+  end
+end