stable-cli-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cb7161cbe3a5e9ed3d651e059f0884fd065cf1281a13baf1ee7f518e47ce66c4
+  data.tar.gz: 882e21ccd55072e66bf5f0e4dac8b023b41da126667d17de930876d69827d536
+SHA512:
+  metadata.gz: 4f093a5af1f22b2212280b57bc69afd934b44525378a707c5c0bb399b3645b4ee936aea242e316628015930b3ab4ee3ea0f99bd798dc1aa8514ef98aea775c30
+  data.tar.gz: c87973bf27d5f0d297ebb7104d0197d5432ce360f278d0a5711fe639c928ee58a363a16f1bf07857e79c79ded85849d6721416be00e549019ae522d171a0fe57

data/README.md

@@ -0,0 +1,184 @@
+# Stable CLI (macOS)
+
+Stable is a CLI tool to manage local Rails applications with automatic Caddy setup on macOS, local trusted HTTPS certificates, and easy start/stop functionality.
+
+## Features
+
+- Add and remove Rails apps.
+- Automatically generate and manage local HTTPS certificates using `mkcert`.
+- Automatically update `/etc/hosts` for `.test` domains.
+- Start Rails apps with integrated Caddy reverse proxy.
+- Reload Caddy after adding/removing apps.
+- List all registered apps.
+
+## Installation
+
+### From source
+
+```bash
+# Clone the repository
+git clone git@github.com:dannysimfukwe/stable-rails.git
+cd stable-rails
+
+# Install dependencies
+bundle install
+```
+
+### As a gem
+
+```bash
+gem install stable
+```
+
+## Setup
+
+Initialize Caddy home and required directories:
+
+```bash
+stable setup
+```
+
+This will create:  
+- `~/StableCaddy/` for Caddy configuration.  
+- `~/StableCaddy/certs` for generated certificates.  
+- `~/StableCaddy/Caddyfile` for Caddy configuration.  
+
+## CLI Commands
+
+### List apps
+
+```bash
+stable list
+```
+
+Lists all registered apps and their domains.
+
+### Add a Rails app
+
+```bash
+stable add /path/to/rails_app
+```
+
+This will:  
+- Register the app.  
+- Add a `/etc/hosts` entry.  
+- Generate local trusted HTTPS certificates.  
+- Add a Caddy reverse proxy block.  
+- Reload Caddy.
+
+### Remove a Rails app
+
+```bash
+stable remove app_name
+```
+
+This will:  
+- Remove the app from registry.  
+- Remove `/etc/hosts` entry.  
+- Remove the Caddy reverse proxy block.  
+- Reload Caddy.
+
+### Start an app
+
+```bash
+rvmsudo stable start app_name
+```
+
+Starts the Rails server on the assigned port and ensures Caddy is running with the proper reverse proxy. Rails logs can be viewed in your terminal.
+
+### Stop an app
+
+```bash
+stable stop app_name
+```
+
+Stops the Rails server running on the assigned port.
+
+### Secure an app manually
+
+```bash
+rvmsudo stable secure app_name.test
+```
+
+Generates or updates trusted local HTTPS certificates and reloads Caddy.
+
+### Reload Caddy
+
+```bash
+stable caddy reload
+```
+
+Reloads Caddy configuration after changes.
+
+### Health check
+
+```bash
+stable doctor
+```
+
+Checks the environment, RVM/Ruby, Caddy, mkcert, and app readiness.
+
+### Upgrade Ruby for an app
+
+```bash
+stable upgrade-ruby myapp 3.4.4
+```
+
+Upgrades the Ruby version for a specific app, updating `.ruby-version` and ensuring gemset compatibility.
+
+### Create a new Rails app
+
+```bash
+stable new myapp [--ruby 3.4.4] [--rails 7.0.7.1] [--skip-ssl]
+```
+
+Creates a new Rails app, generates `.ruby-version`, installs Rails, adds the app to Stable, and optionally secures it with HTTPS.
+
+## Paths
+
+- Caddy home: `~/StableCaddy`  
+- Caddyfile: `~/StableCaddy/Caddyfile`  
+- Certificates: `~/StableCaddy/certs`  
+- Registered apps: `~/StableCaddy/apps.yml`  
+
+## Dependencies
+
+- Homebrew  
+- Caddy  
+- mkcert  
+- RVM (or rbenv fallback)
+
+`ensure_dependencies!` will install missing dependencies automatically.
+
+## Known Issues
+
+- Sometimes you may see:  
+```
+TCPSocket#initialize: Connection refused - connect(2) for "127.0.0.1" port 300.. (Errno::ECONNREFUSED)
+```
+This usually disappears after a few seconds when Caddy reloads. If it persists, run:
+
+```bash
+rvmsudo stable secure myapp.test
+```
+
+- Some commands may need to be run consecutively for proper setup:  
+```bash
+stable setup
+rvmsudo stable add myapp
+rvmsudo stable secure myapp.test
+stable start myapp
+```
+
+- PATH warnings from RVM may appear on the first run. Make sure your shell is properly configured for RVM.
+
+## Notes
+
+- Make sure to run `stable setup` initially.  
+- Requires `sudo` to modify `/etc/hosts`.  
+- Rails apps are started on ports assigned by Stable (default 3000+).  
+- Domains are automatically suffixed with `.test`.  
+
+## License
+
+MIT License

data/bin/stable

@@ -0,0 +1,4 @@
+
+#!/usr/bin/env ruby
+require "stable"
+Stable::CLI.start(ARGV)

data/lib/stable/bootstrap.rb

@@ -0,0 +1,36 @@
+require "fileutils"
+
+module Stable
+  module Bootstrap
+    def self.run!
+      FileUtils.mkdir_p(Paths.root)
+      FileUtils.mkdir_p(Paths.caddy_dir)
+      FileUtils.mkdir_p(Paths.certs_dir)
+
+      unless File.exist?(Paths.apps_file)
+        File.write(Paths.apps_file, "--- []\n")
+      end
+
+      unless File.exist?(Paths.caddyfile)
+        File.write(Paths.caddyfile, "")
+      end
+
+      disable_rvm_autolibs!
+    end
+
+    def self.disable_rvm_autolibs!
+      return unless system("which rvm > /dev/null")
+
+      # Only run once
+      marker = File.join(Paths.root, ".rvm_autolibs_disabled")
+      return if File.exist?(marker)
+
+      puts "Configuring RVM (disabling autolibs)..."
+
+      system("bash -lc 'rvm autolibs disable'")
+      system("bash -lc 'echo rvm_silence_path_mismatch_check_flag=1 >> ~/.rvmrc'")
+
+      FileUtils.touch(marker)
+    end
+  end
+end

data/lib/stable/cli.rb

@@ -0,0 +1,545 @@
+require "thor"
+require "etc"
+require "fileutils"
+require_relative "scanner"
+require_relative "registry"
+
+module Stable
+  class CLI < Thor
+
+    HOSTS_FILE = "/etc/hosts".freeze
+
+    def initialize(*)
+      super
+      Stable::Bootstrap.run!
+      ensure_dependencies!
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "new NAME", "Create, secure, and run a new Rails app"
+    method_option :ruby, type: :string, desc: "Ruby version (defaults to current Ruby)"
+    method_option :rails, type: :string, desc: "Rails version to install (optional)"
+    method_option :port, type: :numeric, desc: "Port to run Rails app on"
+    method_option :skip_ssl, type: :boolean, default: false, desc: "Skip HTTPS setup"
+    def new(name, ruby: RUBY_VERSION, rails: nil, port: nil)
+      port ||= next_free_port
+      app_path = File.expand_path(name)
+
+      abort "Folder already exists: #{app_path}" if File.exist?(app_path)
+
+      # --- Ensure RVM and Ruby ---
+      ensure_rvm!
+      puts "Using Ruby #{ruby} with RVM gemset #{name}..."
+      system("bash -lc 'rvm #{ruby}@#{name} --create do true'") or abort("Failed to create RVM gemset")
+
+      # --- Install Rails in gemset if needed ---
+      rails_version = rails || "latest"
+      rails_check = system("bash -lc 'rvm #{ruby}@#{name} do gem list -i rails#{rails ? " -v #{rails}" : ""}'")
+      unless rails_check
+        puts "Installing Rails #{rails_version} in gemset..."
+        system("bash -lc 'rvm #{ruby}@#{name} do gem install rails #{rails ? "-v #{rails}" : ""}'") or abort("Failed to install Rails")
+      end
+
+      # --- Create Rails app ---
+      puts "Creating Rails app #{name} (Ruby #{ruby})..."
+      system("bash -lc 'rvm #{ruby}@#{name} do rails new #{app_path}'") or abort("Rails app creation failed")
+
+      # --- Add .ruby-version and .ruby-gemset ---
+      Dir.chdir(app_path) do
+        File.write(".ruby-version", "#{ruby}\n")
+        File.write(".ruby-gemset", "#{name}\n")
+
+        # --- Install gems inside gemset ---
+        puts "Running bundle install..."
+        system("bash -lc 'rvm #{ruby}@#{name} do bundle install --jobs=4 --retry=3'") or abort("bundle install failed")
+      end
+
+      # --- Add app to registry ---
+      domain = "#{name}.test"
+      apps = Registry.apps
+      apps << { name: name, path: app_path, domain: domain, port: port, ruby: ruby }
+      Registry.save(apps)
+
+      # --- Host entry & certificate ---
+      add_host_entry(domain)
+      generate_cert(domain) unless options[:skip_ssl]
+      update_caddyfile(domain, port)
+      ensure_caddy_running!
+      caddy_reload
+
+      # --- Start Rails server ---
+      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))
+      pid = spawn("bash -lc 'rvm #{ruby}@#{name} do cd #{app_path} && bundle exec rails s -p #{port} >> #{log_file} 2>&1'")
+      Process.detach(pid)
+
+      wait_for_port(port)
+      puts "✔ #{name} running at https://#{domain}"
+    end
+
+
+    desc "list", "List detected apps"
+    def list
+      apps = Registry.apps
+      if apps.empty?
+        puts "No apps found."
+      else
+        apps.each do |app|
+          puts "#{app[:name]} -> https://#{app[:domain]}"
+        end
+      end
+    end
+
+    desc "add FOLDER", "Add a Rails app folder"
+    def add(folder)
+      folder = File.expand_path(folder)
+      unless File.exist?(File.join(folder, "config", "application.rb"))
+        puts "Not a Rails app: #{folder}"
+        return
+      end
+
+      apps = Registry.apps
+      name = File.basename(folder)
+      domain = "#{name}.test"
+
+      if apps.any? { |a| a[:path] == folder }
+        puts "App already exists: #{name}"
+        return
+      end
+
+      port = next_free_port
+      ruby = detect_ruby_version(folder)
+
+      apps << { name: name, path: folder, domain: domain, port: port, ruby: ruby }
+      Registry.save(apps)
+      puts "Added #{name} -> https://#{domain} (port #{port})"
+
+      add_host_entry(domain)
+      generate_cert(domain)
+      update_caddyfile(domain, port)
+      caddy_reload
+    end
+
+    desc "remove NAME", "Remove an app by name"
+    def remove(name)
+      apps = Registry.apps
+      app = apps.find { |a| a[:name] == name }
+      if app.nil?
+        puts "No app found with name #{name}"
+        return
+      end
+
+      new_apps = apps.reject { |a| a[:name] == name }
+      Registry.save(new_apps)
+      puts "Removed #{name}"
+
+      remove_host_entry(app[:domain])
+      remove_caddy_entry(app[:domain])
+      caddy_reload
+    end
+
+    desc "start NAME", "Start a Rails app with its correct Ruby version"
+    def start(name)
+      app = Registry.apps.find { |a| a[:name] == name }
+      unless app
+        puts "No app found with name #{name}"
+        return
+      end
+
+      port = app[:port] || next_free_port
+      ruby = app[:ruby]
+
+      puts "Starting #{name} on port #{port}#{ruby ? " (Ruby #{ruby})" : ""}..."
+
+      log_file = File.join(app[:path], "log", "stable.log")
+      FileUtils.mkdir_p(File.dirname(log_file))
+
+      ruby_exec =
+        if ruby
+          if rvm_available?
+            ensure_rvm_ruby!(ruby)
+            "rvm #{ruby}@#{name} do"
+          elsif rbenv_available?
+            ensure_rbenv_ruby!(ruby)
+            "RBENV_VERSION=#{ruby}"
+          else
+            puts "No Ruby version manager found (rvm or rbenv)"
+            return
+          end
+        end
+
+      cmd = <<~CMD
+        cd #{app[:path]} &&
+        #{ruby_exec} bundle exec rails s -p #{port}
+      CMD
+
+      pid = spawn(
+        "bash",
+        "-lc",
+        cmd,
+        out: log_file,
+        err: log_file
+      )
+
+      Process.detach(pid)
+
+      generate_cert(app[:domain])
+      update_caddyfile(app[:domain], port)
+      wait_for_port(port)
+      caddy_reload
+
+      puts "#{name} started on https://#{app[:domain]}"
+    end
+
+    desc "stop NAME", "Stop a Rails app (default port 3000)"
+    def stop(name)
+      app = Registry.apps.find { |a| a[:name] == name }
+
+      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 #{name}"
+      end
+    end
+
+    desc "setup", "Sets up Caddy and local trusted certificates"
+    def setup
+      FileUtils.mkdir_p(Stable::Paths.root)
+      File.write(Stable::Paths.caddyfile, "") unless File.exist?(Stable::Paths.caddyfile)
+      ensure_caddy_running!
+      puts "Caddy home initialized at #{Stable::Paths.root}"
+    end
+
+    desc "caddy reload", "Reloads Caddy after adding/removing apps"
+    def caddy_reload
+      if system("which caddy > /dev/null")
+        system("caddy reload --config #{Stable::Paths.caddyfile}")
+        puts "Caddy reloaded"
+      else
+        puts "Caddy not found. Install Caddy first."
+      end
+    end
+
+    desc "secure DOMAIN", "Generate trusted local HTTPS cert for a specific folder/domain"
+    def secure(domain)
+      app = Registry.apps.find { |a| a[:domain] == domain }
+      unless app
+        puts "No app found with domain #{domain}"
+        return
+      end
+      secure_app(domain, app[:path], app[:port])
+      caddy_reload
+      puts "Secured https://#{domain}"
+    end
+
+
+    desc "doctor", "Check Stable system health"
+    def doctor
+      puts "Stable doctor\n\n"
+
+      puts "Ruby version: #{RUBY_VERSION}"
+      puts "RVM: #{rvm_available? ? "yes" : "no"}"
+      puts "rbenv: #{rbenv_available? ? "yes" : "no"}"
+      puts "Caddy: #{system("which caddy > /dev/null") ? "yes" : "no"}"
+      puts "mkcert: #{system("which mkcert > /dev/null") ? "yes" : "no"}"
+
+      Registry.apps.each do |app|
+        status = port_in_use?(app[:port]) ? "running" : "stopped"
+        puts "#{app[:name]} → Ruby #{app[:ruby] || "default"} (#{status})"
+      end
+    end
+
+    desc "upgrade-ruby NAME VERSION", "Upgrade Ruby for an app"
+    def upgrade_ruby(name, version)
+      app = Registry.apps.find { |a| a[:name] == name }
+      unless app
+        puts "No app named #{name}"
+        return
+      end
+
+      if rvm_available?
+        system("bash -lc 'rvm install #{version}'")
+      elsif rbenv_available?
+        system("rbenv install #{version}")
+      else
+        puts "No Ruby version manager found"
+        return
+      end
+
+      File.write(File.join(app[:path], ".ruby-version"), version)
+      app[:ruby] = version
+      Registry.save(Registry.apps)
+
+      puts "#{name} now uses Ruby #{version}"
+    end
+
+    private
+
+    def add_host_entry(domain)
+      entry = "127.0.0.1\t#{domain}"
+      hosts = File.read(HOSTS_FILE)
+      unless hosts.include?(domain)
+        puts "Adding #{domain} to #{HOSTS_FILE}..."
+        File.open(HOSTS_FILE, "a") { |f| f.puts entry }
+        system("dscacheutil -flushcache; sudo killall -HUP mDNSResponder")
+      end
+    rescue Errno::EACCES
+      ensure_hosts_entry(domain)
+    end
+
+    def remove_host_entry(domain)
+      begin
+        hosts = File.read(HOSTS_FILE)
+        new_hosts = hosts.lines.reject { |line| line.include?(domain) }.join
+        File.write(HOSTS_FILE, new_hosts)
+        system("dscacheutil -flushcache; sudo killall -HUP mDNSResponder")
+      rescue Errno::EACCES
+        puts "Permission denied updating #{HOSTS_FILE}. Run 'sudo stable remove #{domain}' to remove hosts entry."
+      end
+    end
+
+    def ensure_hosts_entry(domain)
+      entry = "127.0.0.1\t#{domain}"
+
+      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
+
+      system("dscacheutil -flushcache; sudo killall -HUP mDNSResponder")
+    end
+
+    def secure_app(domain, _folder, port)
+      ensure_certs_dir! 
+
+      cert_path = File.join(Stable::Paths.certs_dir, "#{domain}.pem")
+      key_path  = File.join(Stable::Paths.certs_dir, "#{domain}-key.pem")
+
+      # Generate certificates if missing
+      if system("which mkcert > /dev/null")
+        unless File.exist?(cert_path) && File.exist?(key_path)
+          system("mkcert -cert-file #{cert_path} -key-file #{key_path} #{domain}")
+        end
+      else
+        puts "mkcert not found. Please install mkcert."
+        return
+      end
+
+      # Auto-add Caddy block if not already in Caddyfile
+      add_caddy_block(domain, cert_path, key_path, port)
+      caddy_reload
+    end
+
+    def add_caddy_block(domain, cert, key, port)
+        caddyfile = Stable::Paths.caddyfile
+        FileUtils.touch(caddyfile) unless File.exist?(caddyfile)
+        content = File.read(caddyfile)
+
+        return if content.include?(domain) # don't duplicate
+
+        block = <<~CADDY
+
+          https://#{domain} {
+              reverse_proxy 127.0.0.1:#{port}
+              tls #{cert} #{key}
+          }
+        CADDY
+
+        File.write(caddyfile, content + block)
+        system("caddy fmt --overwrite #{caddyfile}")
+      end
+
+
+    # Remove Caddyfile entry for the domain
+    def remove_caddy_entry(domain)
+      return unless File.exist?(Stable::Paths.caddyfile)
+      content = File.read(Stable::Paths.caddyfile)
+      # Remove block starting with https://<domain> { ... }
+      new_content = content.gsub(/https:\/\/#{Regexp.escape(domain)}\s*\{[^\}]*\}/m, "")
+      File.write(Stable::Paths.caddyfile, new_content)
+    end
+
+    def ensure_dependencies!
+      unless system("which brew > /dev/null")
+        puts "Homebrew is required. Install it first: https://brew.sh"
+        exit 1
+      end
+
+      unless system("which caddy > /dev/null")
+        puts "Installing Caddy..."
+        system("brew install caddy")
+      end
+
+      unless system("which mkcert > /dev/null")
+        puts "Installing mkcert..."
+        system("brew install mkcert nss")
+        system("mkcert -install")
+      end
+    end
+    def ensure_caddy_running!
+      api_port = 2019
+
+      # Check if Caddy API is reachable
+      require 'socket'
+      begin
+        TCPSocket.new('127.0.0.1', api_port).close
+        puts "Caddy already running."
+      rescue Errno::ECONNREFUSED
+        puts "Starting Caddy in background..."
+        system("caddy run --config #{Stable::Paths.caddyfile} --adapter caddyfile --watch --resume &")
+        sleep 3
+      end
+    end
+
+
+    def next_free_port
+      used_ports = Registry.apps.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 generate_cert(domain)
+      cert_path = File.join(Stable::Paths.certs_dir, "#{domain}.pem")
+      key_path  = File.join(Stable::Paths.certs_dir, "#{domain}-key.pem")
+      FileUtils.mkdir_p(Stable::Paths.certs_dir)
+
+      unless File.exist?(cert_path) && File.exist?(key_path)
+        if system("which mkcert > /dev/null")
+          system("mkcert -cert-file #{cert_path} -key-file #{key_path} #{domain}")
+        else
+          puts "mkcert not found. Please install mkcert."
+        end
+      end
+    end
+
+    def update_caddyfile(domain, port)
+      caddyfile = Stable::Paths.caddyfile
+      FileUtils.touch(caddyfile) unless File.exist?(caddyfile)
+      content = File.read(caddyfile)
+
+      # remove existing block for domain
+      content.gsub!(/https:\/\/#{Regexp.escape(domain)}\s*\{[^\}]*\}/m, "")
+
+      # add new block
+      cert_path = File.join(Stable::Paths.certs_dir, "#{domain}.pem")
+      key_path  = File.join(Stable::Paths.certs_dir, "#{domain}-key.pem")
+      block = <<~CADDY
+
+        https://#{domain} {
+            reverse_proxy 127.0.0.1:#{port}
+            tls #{cert_path} #{key_path}
+        }
+      CADDY
+
+      File.write(caddyfile, content + block)
+      system("caddy fmt --overwrite #{caddyfile}")
+    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 => e
+        puts "Could not change ownership: #{e.message}"
+      end
+
+      # Restrict permissions for security
+      Dir.glob("#{certs_dir}/*.pem").each do |pem|
+        FileUtils.chmod(0600, pem)
+      end
+    end
+
+    def wait_for_port(port, timeout: 5)
+      require 'socket'
+      start_time = Time.now
+      loop do
+        begin
+          TCPSocket.new('127.0.0.1', port).close
+          break
+        rescue Errno::ECONNREFUSED
+          raise "Timeout waiting for port #{port}" if Time.now - start_time > timeout
+          sleep 0.1
+        end
+      end
+    end
+
+    def ensure_rvm!
+      return if system("which rvm > /dev/null")
+
+      puts "RVM not found. Installing RVM..."
+
+      install_cmd = <<~CMD
+        curl -sSL https://get.rvm.io | bash -s stable
+      CMD
+
+      unless system(install_cmd)
+        abort "RVM installation failed"
+      end
+
+      # Load RVM into current process
+      rvm_script = File.expand_path("~/.rvm/scripts/rvm")
+      unless File.exist?(rvm_script)
+        abort "RVM installed but could not be loaded"
+      end
+
+      ENV["PATH"] = "#{File.expand_path('~/.rvm/bin')}:#{ENV['PATH']}"
+
+      system(%(bash -lc "source #{rvm_script} && rvm --version")) ||
+        abort("RVM installed but not functional")
+    end
+
+    def 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 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 rvm_available?
+      system("bash -lc 'command -v rvm > /dev/null'")
+    end
+
+    def rbenv_available?
+      system("command -v rbenv > /dev/null")
+    end
+
+    def ensure_rvm_ruby!(version)
+      system("bash -lc 'rvm list strings | grep -q #{version} || rvm install #{version}'")
+    end
+
+    def ensure_rbenv_ruby!(version)
+      system("rbenv versions | grep -q #{version} || rbenv install #{version}")
+    end
+
+  end
+end

data/lib/stable/paths.rb

@@ -0,0 +1,23 @@
+module Stable
+  module Paths
+    def self.root
+      File.expand_path("~/StableCaddy")
+    end
+
+    def self.caddy_dir
+      root
+    end
+
+    def self.caddyfile
+      File.join(caddy_dir, "Caddyfile")
+    end
+
+    def self.certs_dir
+      File.join(root, "certs")
+    end
+
+    def self.apps_file
+      File.join(root, "apps.yml")
+    end
+  end
+end

data/lib/stable/registry.rb

@@ -0,0 +1,19 @@
+require "yaml"
+require "fileutils"
+
+module Stable
+  class Registry
+    def self.file_path
+      File.join(Stable.root, "apps.yml")
+    end
+
+    def self.save(apps)
+      FileUtils.mkdir_p(Stable.root)
+      File.write(file_path, apps.to_yaml)
+    end
+
+    def self.apps
+      File.exist?(file_path) ? YAML.load_file(file_path) : []
+    end
+  end
+end

data/lib/stable/scanner.rb

@@ -0,0 +1,8 @@
+
+module Stable
+  class Scanner
+    def self.run
+      Registry.save([])
+    end
+  end
+end

data/lib/stable.rb

@@ -0,0 +1,14 @@
+module Stable
+  def self.root
+    File.expand_path("~/.stable")
+  end
+end
+
+require "fileutils"
+require_relative "stable/paths"
+require_relative "stable/cli"
+require_relative "stable/registry"
+require_relative "stable/scanner"
+require_relative "stable/bootstrap"
+
+

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: stable-cli-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Danny Simfukwe
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fileutils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "# Stable CLI (macOS)\n\nStable is a CLI tool to manage local Rails applications
+  with automatic Caddy setup on macOS, local trusted HTTPS certificates, and easy
+  start/stop functionality.\n\n## Features\n\n- Add and remove Rails apps.\n- Automatically
+  generate and manage local HTTPS certificates using `mkcert`.\n- Automatically update
+  `/etc/hosts` for `.test` domains.\n- Start Rails apps with integrated Caddy reverse
+  proxy.\n- Reload Caddy after adding/removing apps.\n- List all registered apps.\n\n##
+  Installation\n\n### From source\n\n```bash\n# Clone the repository\ngit clone git@github.com:dannysimfukwe/stable-rails.git\ncd
+  stable-rails\n\n# Install dependencies\nbundle install\n```\n\n### As a gem\n\n```bash\ngem
+  install stable\n```\n\n## Setup\n\nInitialize Caddy home and required directories:\n\n```bash\nstable
+  setup\n```\n\nThis will create:  \n- `~/StableCaddy/` for Caddy configuration.  \n-
+  `~/StableCaddy/certs` for generated certificates.  \n- `~/StableCaddy/Caddyfile`
+  for Caddy configuration.  \n\n## CLI Commands\n\n### List apps\n\n```bash\nstable
+  list\n```\n\nLists all registered apps and their domains.\n\n### Add a Rails app\n\n```bash\nstable
+  add /path/to/rails_app\n```\n\nThis will:  \n- Register the app.  \n- Add a `/etc/hosts`
+  entry.  \n- Generate local trusted HTTPS certificates.  \n- Add a Caddy reverse
+  proxy block.  \n- Reload Caddy.\n\n### Remove a Rails app\n\n```bash\nstable remove
+  app_name\n```\n\nThis will:  \n- Remove the app from registry.  \n- Remove `/etc/hosts`
+  entry.  \n- Remove the Caddy reverse proxy block.  \n- Reload Caddy.\n\n### Start
+  an app\n\n```bash\nrvmsudo stable start app_name\n```\n\nStarts the Rails server
+  on the assigned port and ensures Caddy is running with the proper reverse proxy.
+  Rails logs can be viewed in your terminal.\n\n### Stop an app\n\n```bash\nstable
+  stop app_name\n```\n\nStops the Rails server running on the assigned port.\n\n###
+  Secure an app manually\n\n```bash\nrvmsudo stable secure app_name.test\n```\n\nGenerates
+  or updates trusted local HTTPS certificates and reloads Caddy.\n\n### Reload Caddy\n\n```bash\nstable
+  caddy reload\n```\n\nReloads Caddy configuration after changes.\n\n### Health check\n\n```bash\nstable
+  doctor\n```\n\nChecks the environment, RVM/Ruby, Caddy, mkcert, and app readiness.\n\n###
+  Upgrade Ruby for an app\n\n```bash\nstable upgrade-ruby myapp 3.4.4\n```\n\nUpgrades
+  the Ruby version for a specific app, updating `.ruby-version` and ensuring gemset
+  compatibility.\n\n### Create a new Rails app\n\n```bash\nstable new myapp [--ruby
+  3.4.4] [--rails 7.0.7.1] [--skip-ssl]\n```\n\nCreates a new Rails app, generates
+  `.ruby-version`, installs Rails, adds the app to Stable, and optionally secures
+  it with HTTPS.\n\n## Paths\n\n- Caddy home: `~/StableCaddy`  \n- Caddyfile: `~/StableCaddy/Caddyfile`
+  \ \n- Certificates: `~/StableCaddy/certs`  \n- Registered apps: `~/StableCaddy/apps.yml`
+  \ \n\n## Dependencies\n\n- Homebrew  \n- Caddy  \n- mkcert  \n- RVM (or rbenv fallback)\n\n`ensure_dependencies!`
+  will install missing dependencies automatically.\n\n## Known Issues\n\n- Sometimes
+  you may see:  \n```\nTCPSocket#initialize: Connection refused - connect(2) for \"127.0.0.1\"
+  port 300.. (Errno::ECONNREFUSED)\n```\nThis usually disappears after a few seconds
+  when Caddy reloads. If it persists, run:\n\n```bash\nrvmsudo stable secure myapp.test\n```\n\n-
+  Some commands may need to be run consecutively for proper setup:  \n```bash\nstable
+  setup\nrvmsudo stable add myapp\nrvmsudo stable secure myapp.test\nstable start
+  myapp\n```\n\n- PATH warnings from RVM may appear on the first run. Make sure your
+  shell is properly configured for RVM.\n\n## Notes\n\n- Make sure to run `stable
+  setup` initially.  \n- Requires `sudo` to modify `/etc/hosts`.  \n- Rails apps are
+  started on ports assigned by Stable (default 3000+).  \n- Domains are automatically
+  suffixed with `.test`.  \n\n## License\n\nMIT License\n"
+email:
+- dannysimfukwe@gmail.com
+executables:
+- stable
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/stable
+- lib/stable.rb
+- lib/stable/bootstrap.rb
+- lib/stable/cli.rb
+- lib/stable/paths.rb
+- lib/stable/registry.rb
+- lib/stable/scanner.rb
+homepage: https://github.com/dannysimfukwe/stable-rails
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: CLI tool to manage local Rails apps with automatic Caddy and HTTPS setup
+test_files: []