stable-cli-rails 0.8.4 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea91d16ba356305a67c3627e75bfe16f2d780c0523d5420485accf4b4b70a2ca
-  data.tar.gz: c7344e77e0294a139d14e588fb28706b9c2e22cb5b1b00ae0aaa8e05d182b74a
+  metadata.gz: f9eaea11c07941f7a09145d69497c0aff9ee2d85cc2d686fe238b5031e0c554b
+  data.tar.gz: c9ba35f2b2a9ae12be1070d9811fc75e66d21c4f751fc99a2ecc0cad59128e7d
 SHA512:
-  metadata.gz: ab9bfc8f6f5c5588ad6f9b8819ea4b504653ebe40e885e0796c51082e33b8a4e02189aca720dbed0edb971e558c6f4e23d2d405189ab53301eef6283fe3d4280
-  data.tar.gz: 8de8596f02772e8a98538ec45b52648869dde114bc65cf5958abff944a5c4c52389c278d1c821589952d0ef347974f22a7c0f9bb25f90ef7159370bfb10130ec
+  metadata.gz: 866da469383dc2e71c0bc766a813391586be2f0af2447b8a063565c4f30d22b6cb45f113c8a53736bd5b8e6dfb1dcf647b5ee42667b5ad2601b1d703cad31f0b
+  data.tar.gz: fec6d17ade09f6bf898eed2b12de5ca060e249b5e3ca5b6cf72fdf78778dd743ff23f147e410767adfd8ae672cd33c640027b639c2c99c9f3dcfad0f5b29a3b1

data/lib/stable/cli.rb

@@ -136,8 +136,22 @@ module Stable
     end
 
     desc 'open APP', 'Open a running app in the browser'
-    def open(app_name)
-      Stable::Commands::Open.new(app_name).call
+    def open(name)
+      Stable::Commands::Open.new(name).call
+    end
+
+    desc 'share APP [PROVIDER]', 'Share app via public tunnel'
+    method_option :provider, type: :string, default: nil, desc: 'Tunnel provider (ngrok, stable)'
+    method_option :qrcode, type: :boolean, default: false, desc: 'Generate a Qr code for the shared URL'
+    def share(name, provider = nil, qrcode: false)
+      provider ||= options[:provider] || 'ngrok'
+      Commands::Share.new(name, provider: provider.to_sym, qrcode: options[:qrcode]).call
+    end
+
+    desc 'workdir APP', 'Open the app folder in a code editor'
+    method_option :editor, type: :string, default: 'vscode', desc: 'Code editor to use (vscode, sublime, atom, etc.)'
+    def workdir(name)
+      Commands::Workdir.new(name, options[:editor]).call
     end
 
     private

data/lib/stable/commands/destroy.rb

@@ -11,94 +11,7 @@ module Stable
       end
 
       def call
-        app = Services::AppRegistry.find(@name)
-        abort 'App not found' unless app
-
-        display_warning(app)
-        return unless confirm_destruction
-
-        puts "\n🗑️  Destroying #{@name}..."
-        perform_destruction(app)
-        puts "✅ Successfully destroyed #{@name}"
-      end
-
-      private
-
-      def display_warning(app)
-        puts "⚠️  WARNING: This will permanently delete the application '#{@name}'"
-        puts "   Path: #{app[:path]}"
-        puts "   Domain: #{app[:domain]}"
-        puts '   This action CANNOT be undone!'
-        puts ''
-      end
-
-      def confirm_destruction
-        print "Type '#{@name}' to confirm destruction: "
-        confirmation = $stdin.gets&.strip
-        puts ''
-
-        if confirmation == @name
-          true
-        else
-          puts "❌ Destruction cancelled - confirmation didn't match"
-          false
-        end
-      end
-
-      def perform_destruction(app)
-        # Stop the app if running
-        Services::ProcessManager.stop(app)
-
-        # Remove from infrastructure
-        Services::HostsManager.remove(app[:domain])
-        Services::CaddyManager.remove(app[:domain])
-        Services::AppRegistry.remove(@name)
-
-        # Clean up RVM gemset
-        cleanup_rvm_gemset(app)
-
-        # Delete the project directory
-        delete_project_directory(app[:path])
-
-        # Reload Caddy
-        Services::CaddyManager.reload
-      end
-
-      def cleanup_rvm_gemset(app)
-        # Skip RVM operations in test mode
-        return if ENV['STABLE_TEST_MODE']
-
-        # Only clean up RVM gemsets on Unix-like systems (macOS/Linux)
-        # Windows uses different Ruby version managers
-        return unless Stable::Utils::Platform.unix?
-
-        ruby_version = app[:ruby]
-        # Handle different ruby version formats (e.g., "3.4.7", "ruby-3.4.7")
-        clean_ruby_version = ruby_version.to_s.sub(/^ruby-/, '')
-        gemset_name = "#{clean_ruby_version}@#{@name}"
-
-        puts "   Cleaning up RVM gemset #{gemset_name}..."
-        begin
-          # Use system to run RVM command to delete the gemset
-          system("bash -lc 'source ~/.rvm/scripts/rvm && rvm gemset delete #{gemset_name} --force' 2>/dev/null || true")
-          puts "   ✅ RVM gemset #{gemset_name} cleaned up"
-        rescue StandardError => e
-          puts "   ⚠️  Could not clean up RVM gemset #{gemset_name}: #{e.message}"
-        end
-      end
-
-      def delete_project_directory(path)
-        if ENV['STABLE_TEST_MODE']
-          puts '   Deleting project directory...'
-          return
-        end
-
-        if File.exist?(path)
-          puts '   Deleting project directory...'
-          FileUtils.rm_rf(path)
-        else
-          puts '   Project directory not found (already deleted?)'
-        end
+        Services::AppDestroyer.new(@name).call
       end
     end
   end

data/lib/stable/commands/open.rb

@@ -9,47 +9,7 @@ module Stable
       end
 
       def call
-        app = Services::AppRegistry.find(@app_name)
-        abort "App '#{@app_name}' not found" unless app
-
-        abort "App '#{@app_name}' is not running" unless app[:pid] && process_alive?(app[:pid])
-        url = build_url(app)
-        open_browser(url)
-        puts "✔ Opened #{url}"
-      end
-
-      private
-
-      def build_url(app)
-        scheme = app[:skip_ssl] ? 'http' : 'https'
-        if app[:domain]
-          "#{scheme}://#{app[:domain]}"
-        else
-          "#{scheme}://127.0.0.1:#{app[:port]}"
-        end
-      end
-
-      def open_browser(url)
-        cmd =
-          case RbConfig::CONFIG['host_os']
-          when /darwin/
-            "open #{url}"
-          when /linux/
-            "xdg-open #{url}"
-          when /mswin|mingw/
-            "start #{url}"
-          else
-            abort 'Unsupported OS'
-          end
-
-        system(cmd) || abort('Failed to open browser')
-      end
-
-      def process_alive?(pid)
-        Process.kill(0, pid)
-        true
-      rescue Errno::ESRCH
-        false
+        Services::AppOpener.new(@app_name).call
       end
     end
   end

data/lib/stable/commands/share.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    # Share app's public url
+    class Share
+      def initialize(app_name, provider: :ngrok, qrcode: false)
+        @app_name = app_name
+        @provider = provider
+        @qrcode   = qrcode
+      end
+
+      def call
+        app = Services::AppRegistry.find(@app_name)
+        abort "App '#{@app_name}' not found" unless app
+        abort "App '#{@app_name}' is not running" unless running?(app)
+        Services::Rails::HostAuthorization.allow_ngrok!(app[:path])
+        Services::ProcessManager.stop(app) # stop the app
+        Services::ProcessManager.start(app) # restart the app
+
+        # Pass the real app port here
+        url = Services::Tunneling::Manager
+              .new(provider: @provider)
+              .expose_domain(app[:domain], port: app[:port], skip_ssl: app[:skip_ssl])
+
+        puts "🌐 Shared #{@app_name} at:"
+        puts "   #{url}"
+
+        return unless @qrcode
+
+        Services::Cli::QrCode.print(url)
+      end
+
+      private
+
+      def running?(app)
+        pid = app[:pid]
+        return false unless pid
+
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+  end
+end

data/lib/stable/commands/unshare.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    # Unshare app's public url
+    class UnShare
+      def initialize(app_name, provider: :ngrok)
+        @app_name = app_name
+        @provider = provider
+      end
+
+      def call
+        app = Services::AppRegistry.find(@app_name)
+        abort "App '#{@app_name}' not found" unless app
+        Stable::Services::Rails::HostAuthorization.remove_ngrok!(app[:path])
+      end
+    end
+  end
+end

data/lib/stable/commands/upgrade_ruby.rb

@@ -12,149 +12,7 @@ module Stable
       end
 
       def call
-        app = Services::AppRegistry.find(@name)
-        unless app
-          puts "No app named #{@name}"
-          return
-        end
-
-        current_version = app[:ruby] || RUBY_VERSION
-
-        puts "#{action(current_version, @version)} #{@name} from Ruby #{current_version} to #{@version}..."
-        puts ''
-
-        # Install the target Ruby version if needed
-        platform = Stable::Utils::Platform.current
-
-        if platform == :windows
-          puts '⚠️  Windows detected - Ruby version managers work differently on Windows'
-          puts "   Please manually install Ruby #{@version} using RubyInstaller or your preferred method"
-          puts '   Recommended: https://rubyinstaller.org/'
-          puts '   Then update your PATH to use the new Ruby version'
-          puts ''
-          puts "After installing Ruby #{@version}, update the app configuration manually:"
-          puts "   - Edit .ruby-version file to contain: #{@version}"
-          puts '   - Run: bundle install (in the app directory)'
-          return
-        end
-
-        if Stable::Services::Ruby.rvm_available?
-          puts "Ensuring Ruby #{@version} is available..."
-          system("bash -lc 'rvm install #{@version}'") unless ENV['STABLE_TEST_MODE']
-        elsif Stable::Services::Ruby.rbenv_available?
-          puts "Ensuring Ruby #{@version} is available..."
-          system("rbenv install #{@version}") unless ENV['STABLE_TEST_MODE']
-        else
-          puts '❌ No supported Ruby version manager found'
-          puts '   On macOS/Linux, install RVM (https://rvm.io/) or rbenv (https://github.com/rbenv/rbenv)'
-          puts '   On Windows, use RubyInstaller (https://rubyinstaller.org/)'
-          return
-        end
-
-        # Remove current Ruby environment and install new one fresh
-        puts "🔄 Upgrading #{@name} from Ruby #{current_version} to #{@version}..."
-
-        # 1. Remove current Ruby version/gemset
-        cleanup_rvm_gemset(app)
-
-        # 2. Install new Ruby version
-        setup_new_ruby_version(app, @version)
-
-        puts ''
-        puts "✅ #{@name} #{past_tense_action(action(current_version, @version))} to Ruby #{@version}!"
-        puts "   Old gemset cleared, fresh #{@version}@#{@name} gemset created with gems"
-        puts ''
-        puts "Start with: stable start #{@name}"
-      end
-
-      private
-
-      def cleanup_rvm_gemset(app)
-        # Skip RVM operations in test mode
-        return if ENV['STABLE_TEST_MODE']
-
-        # Only clean up RVM gemsets on Unix-like systems (macOS/Linux)
-        # Windows uses different Ruby version managers
-        return unless Stable::Utils::Platform.unix?
-
-        ruby_version = app[:ruby]
-        # Handle different ruby version formats (e.g., "3.4.7", "ruby-3.4.7")
-        clean_ruby_version = ruby_version.to_s.sub(/^ruby-/, '')
-        gemset_name = "#{clean_ruby_version}@#{@name}"
-
-        puts "   Cleaning up RVM gemset #{gemset_name}..."
-        begin
-          # Use system to run RVM command to delete the gemset
-          system("bash -lc 'source ~/.rvm/scripts/rvm && rvm gemset delete #{gemset_name} --force' 2>/dev/null || true")
-          puts "   ✅ RVM gemset #{gemset_name} cleaned up"
-        rescue StandardError => e
-          puts "   ⚠️  Could not clean up RVM gemset #{gemset_name}: #{e.message}"
-        end
-      end
-
-      def setup_new_ruby_version(app, new_version)
-        unless ENV['STABLE_TEST_MODE']
-          Stable::Services::Ruby.ensure_version(new_version)
-          Stable::Services::Ruby.ensure_rvm!
-
-          # Create gemset
-          Stable::System::Shell.run("bash -lc 'source #{Stable::Services::Ruby.rvm_script} && rvm #{new_version} do rvm gemset create #{@name} || true'")
-
-          rvm_cmd = Stable::Services::Ruby.rvm_prefix(new_version, @name)
-
-          # Install Bundler
-          Stable::System::Shell.run("bash -lc '#{rvm_cmd} gem install bundler --no-document'")
-
-          # Run bundle install
-          Stable::System::Shell.run(rvm_run('bundle install --jobs=4 --retry=3', chdir: app[:path]))
-        end
-
-        # Update app configuration
-        unless ENV['STABLE_TEST_MODE']
-          Dir.chdir(app[:path]) do
-            File.write('.ruby-version', "#{new_version}\n")
-            File.write('.ruby-gemset', "#{@name}\n")
-          end
-        end
-
-        # Update registry
-        Services::AppRegistry.update(@name, ruby: new_version)
-        puts "   ✅ New Ruby #{new_version} environment set up with gems"
-      end
-
-      def rvm_run(cmd, chdir: nil)
-        cd = chdir ? "cd #{chdir} && " : ''
-        "bash -lc '#{cd}source #{Dir.home}/.rvm/scripts/rvm && rvm #{@version}@#{@name} do #{cmd}'"
-      end
-
-      def action(current_version, new_version)
-        current_parts = current_version.split('.').map(&:to_i)
-        new_parts = new_version.split('.').map(&:to_i)
-
-        if new_parts[0] > current_parts[0] ||
-           (new_parts[0] == current_parts[0] && new_parts[1] > current_parts[1]) ||
-           (new_parts[0] == current_parts[0] && new_parts[1] == current_parts[1] && new_parts[2] > current_parts[2])
-          'Upgrading'
-        elsif new_parts[0] < current_parts[0] ||
-              (new_parts[0] == current_parts[0] && new_parts[1] < current_parts[1]) ||
-              (new_parts[0] == current_parts[0] && new_parts[1] == current_parts[1] && new_parts[2] < current_parts[2])
-          'Downgrading'
-        else
-          'Switching'
-        end
-      end
-
-      def past_tense_action(action)
-        case action
-        when 'Upgrading'
-          'upgraded'
-        when 'Downgrading'
-          'downgraded'
-        when 'Switching'
-          'switched'
-        else
-          'updated'
-        end
+        Services::AppUpgrader.new(@name, @version).call
       end
     end
   end

data/lib/stable/commands/workdir.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Stable
+  module Commands
+    # Open App's work director
+    class Workdir
+      EDITOR_COMMANDS = {
+        'vscode' => 'code',
+        'sublime' => 'subl',
+        'atom' => 'atom'
+      }.freeze
+
+      def initialize(app_name, editor)
+        @app_name = app_name
+        @editor   = editor.downcase
+      end
+
+      def call
+        app = Services::AppRegistry.find(@app_name)
+        abort "App '#{@app_name}' not found" unless app
+        abort "App path does not exist: #{app[:path]}" unless Dir.exist?(app[:path])
+
+        editor_cmd = EDITOR_COMMANDS[@editor] || @editor # support custom editors
+        unless system("which #{editor_cmd} > /dev/null 2>&1")
+          abort "Editor command not found: #{editor_cmd}"
+        end
+
+        puts "🚀 Opening #{@app_name} in #{@editor}..."
+        system("#{editor_cmd} #{app[:path]}")
+      end
+    end
+  end
+end

data/lib/stable/services/app_destroyer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    # Service for destroying a Rails application
+    class AppDestroyer
+      def initialize(name)
+        @name = name
+      end
+
+      def call
+        app = AppRegistry.find(@name)
+        abort 'App not found' unless app
+
+        display_warning(app)
+        return unless confirm_destruction?
+
+        puts "\n🗑️  Destroying #{@name}..."
+        perform_destruction(app)
+        puts "✅ Successfully destroyed #{@name}"
+      end
+
+      private
+
+      def display_warning(app)
+        puts "⚠️  WARNING: This will permanently delete the application '#{@name}'"
+        puts "   Path: #{app[:path]}"
+        puts "   Domain: #{app[:domain]}"
+        puts '   This action CANNOT be undone!'
+        puts ''
+      end
+
+      def confirm_destruction?
+        print "Type '#{@name}' to confirm destruction: "
+        confirmation = $stdin.gets&.strip
+        puts ''
+
+        if confirmation == @name
+          true
+        else
+          puts "❌ Destruction cancelled - confirmation didn't match"
+          false
+        end
+      end
+
+      def perform_destruction(app)
+        # Stop the app if running
+        ProcessManager.stop(app)
+
+        # Remove from infrastructure
+        HostsManager.remove(app[:domain])
+        CaddyManager.remove(app[:domain])
+        AppRegistry.remove(@name)
+
+        # Clean up RVM gemset
+        cleanup_rvm_gemset(app)
+
+        # Delete the project directory
+        delete_project_directory(app[:path])
+
+        # Reload Caddy
+        CaddyManager.reload
+      end
+
+      def cleanup_rvm_gemset(app)
+        return if ENV['STABLE_TEST_MODE']
+        return unless Utils::Platform.unix?
+
+        ruby_version = app[:ruby]
+        clean_ruby_version = ruby_version.to_s.sub(/^ruby-/, '')
+        gemset_name = "#{clean_ruby_version}@#{@name}"
+
+        puts "   Cleaning up RVM gemset #{gemset_name}..."
+        begin
+          system("bash -lc 'source ~/.rvm/scripts/rvm && rvm gemset delete #{gemset_name} --force' 2>/dev/null || true")
+          puts "   ✅ RVM gemset #{gemset_name} cleaned up"
+        rescue StandardError => e
+          puts "   ⚠️  Could not clean up RVM gemset #{gemset_name}: #{e.message}"
+        end
+      end
+
+      def delete_project_directory(path)
+        if ENV['STABLE_TEST_MODE']
+          puts '   Deleting project directory...'
+          return
+        end
+
+        if File.exist?(path)
+          puts '   Deleting project directory...'
+          FileUtils.rm_rf(path)
+        else
+          puts '   Project directory not found (already deleted?)'
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/app_opener.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    # Service for opening Rails applications in a browser
+    class AppOpener
+      def initialize(app_name)
+        @app_name = app_name
+      end
+
+      def call
+        app = AppRegistry.find(@app_name)
+        abort "App '#{@app_name}' not found" unless app
+        abort "App '#{@app_name}' is not running" unless app[:pid] && process_alive?(app[:pid])
+        url = build_url(app)
+        open_browser(url)
+        puts "✔ Opened #{url}"
+      end
+
+      private
+
+      def build_url(app)
+        scheme = app[:skip_ssl] ? 'http' : 'https'
+        if app[:domain]
+          "#{scheme}://#{app[:domain]}"
+        else
+          "#{scheme}://127.0.0.1:#{app[:port]}"
+        end
+      end
+
+      def open_browser(url)
+        cmd =
+          case RbConfig::CONFIG['host_os']
+          when /darwin/
+            "open #{url}"
+          when /linux/
+            "xdg-open #{url}"
+          when /mswin|mingw/
+            "start #{url}"
+          else
+            abort 'Unsupported OS'
+          end
+
+        system(cmd) || abort('Failed to open browser')
+      end
+
+      def process_alive?(pid)
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+  end
+end

data/lib/stable/services/app_upgrader.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    # Service for opening Rails applications in a browser
+    class AppUpgrader
+      def initialize(name, version)
+        @name = name
+        @version = version
+      end
+
+      def call
+        app = Services::AppRegistry.find(@name)
+        unless app
+          puts "No app named #{@name}"
+          return
+        end
+
+        current_version = app[:ruby] || RUBY_VERSION
+
+        puts "#{action(current_version, @version)} #{@name} from Ruby #{current_version} to #{@version}..."
+        puts ''
+
+        # Install the target Ruby version if needed
+        platform = Stable::Utils::Platform.current
+
+        if platform == :windows
+          puts '⚠️  Windows detected - Ruby version managers work differently on Windows'
+          puts "   Please manually install Ruby #{@version} using RubyInstaller or your preferred method"
+          puts '   Recommended: https://rubyinstaller.org/'
+          puts '   Then update your PATH to use the new Ruby version'
+          puts ''
+          puts "After installing Ruby #{@version}, update the app configuration manually:"
+          puts "   - Edit .ruby-version file to contain: #{@version}"
+          puts '   - Run: bundle install (in the app directory)'
+          return
+        end
+
+        if Stable::Services::Ruby.rvm_available?
+          puts "Ensuring Ruby #{@version} is available..."
+          system("bash -lc 'rvm install #{@version}'") unless ENV['STABLE_TEST_MODE']
+        elsif Stable::Services::Ruby.rbenv_available?
+          puts "Ensuring Ruby #{@version} is available..."
+          system("rbenv install #{@version}") unless ENV['STABLE_TEST_MODE']
+        else
+          puts '❌ No supported Ruby version manager found'
+          puts '   On macOS/Linux, install RVM (https://rvm.io/) or rbenv (https://github.com/rbenv/rbenv)'
+          puts '   On Windows, use RubyInstaller (https://rubyinstaller.org/)'
+          return
+        end
+
+        # Remove current Ruby environment and install new one fresh
+        puts "🔄 Upgrading #{@name} from Ruby #{current_version} to #{@version}..."
+
+        # 1. Remove current Ruby version/gemset
+        cleanup_rvm_gemset(app)
+
+        # 2. Install new Ruby version
+        setup_new_ruby_version(app, @version)
+
+        puts ''
+        puts "✅ #{@name} #{past_tense_action(action(current_version, @version))} to Ruby #{@version}!"
+        puts "   Old gemset cleared, fresh #{@version}@#{@name} gemset created with gems"
+        puts ''
+        puts "Start with: stable start #{@name}"
+      end
+
+      private
+
+      def cleanup_rvm_gemset(app)
+        # Skip RVM operations in test mode
+        return if ENV['STABLE_TEST_MODE']
+
+        # Only clean up RVM gemsets on Unix-like systems (macOS/Linux)
+        # Windows uses different Ruby version managers
+        return unless Stable::Utils::Platform.unix?
+
+        ruby_version = app[:ruby]
+        # Handle different ruby version formats (e.g., "3.4.7", "ruby-3.4.7")
+        clean_ruby_version = ruby_version.to_s.sub(/^ruby-/, '')
+        gemset_name = "#{clean_ruby_version}@#{@name}"
+
+        puts "   Cleaning up RVM gemset #{gemset_name}..."
+        begin
+          # Use system to run RVM command to delete the gemset
+          system("bash -lc 'source ~/.rvm/scripts/rvm && rvm gemset delete #{gemset_name} --force' 2>/dev/null || true")
+          puts "   ✅ RVM gemset #{gemset_name} cleaned up"
+        rescue StandardError => e
+          puts "   ⚠️  Could not clean up RVM gemset #{gemset_name}: #{e.message}"
+        end
+      end
+
+      def setup_new_ruby_version(app, new_version)
+        unless ENV['STABLE_TEST_MODE']
+          Stable::Services::Ruby.ensure_version(new_version)
+          Stable::Services::Ruby.ensure_rvm!
+
+          # Create gemset
+          Stable::System::Shell.run("bash -lc 'source #{Stable::Services::Ruby.rvm_script} && rvm #{new_version} do rvm gemset create #{@name} || true'")
+
+          rvm_cmd = Stable::Services::Ruby.rvm_prefix(new_version, @name)
+
+          # Install Bundler
+          Stable::System::Shell.run("bash -lc '#{rvm_cmd} gem install bundler --no-document'")
+
+          # Run bundle install
+          Stable::System::Shell.run(rvm_run('bundle install --jobs=4 --retry=3', chdir: app[:path]))
+        end
+
+        # Update app configuration
+        unless ENV['STABLE_TEST_MODE']
+          Dir.chdir(app[:path]) do
+            File.write('.ruby-version', "#{new_version}\n")
+            File.write('.ruby-gemset', "#{@name}\n")
+          end
+        end
+
+        # Update registry
+        Services::AppRegistry.update(@name, ruby: new_version)
+        puts "   ✅ New Ruby #{new_version} environment set up with gems"
+      end
+
+      def rvm_run(cmd, chdir: nil)
+        cd = chdir ? "cd #{chdir} && " : ''
+        "bash -lc '#{cd}source #{Dir.home}/.rvm/scripts/rvm && rvm #{@version}@#{@name} do #{cmd}'"
+      end
+
+      def action(current_version, new_version)
+        current_parts = current_version.split('.').map(&:to_i)
+        new_parts = new_version.split('.').map(&:to_i)
+
+        if new_parts[0] > current_parts[0] ||
+           (new_parts[0] == current_parts[0] && new_parts[1] > current_parts[1]) ||
+           (new_parts[0] == current_parts[0] && new_parts[1] == current_parts[1] && new_parts[2] > current_parts[2])
+          'Upgrading'
+        elsif new_parts[0] < current_parts[0] ||
+              (new_parts[0] == current_parts[0] && new_parts[1] < current_parts[1]) ||
+              (new_parts[0] == current_parts[0] && new_parts[1] == current_parts[1] && new_parts[2] < current_parts[2])
+          'Downgrading'
+        else
+          'Switching'
+        end
+      end
+
+      def past_tense_action(action)
+        case action
+        when 'Upgrading'
+          'upgraded'
+        when 'Downgrading'
+          'downgraded'
+        when 'Switching'
+          'switched'
+        else
+          'updated'
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/cli/qrcode.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rqrcode'
+
+module Stable
+  module Services
+    module Cli
+      # Generate QR code
+      class QrCode
+        def self.print(url)
+          qr = RQRCode::QRCode.new(url)
+
+          puts
+          qr.modules.each do |row|
+            puts row.map { |cell| cell ? '██' : '  ' }.join
+          end
+          puts
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/rails/host_authorization.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    module Rails
+      # Authorize ngro host
+      class HostAuthorization
+        MARKER_BEGIN = '# BEGIN Stable ngrok hosts'
+        MARKER_END   = '# END Stable ngrok hosts'
+
+        def self.allow_ngrok!(app_path)
+          env_file = File.join(app_path, 'config/environments/development.rb')
+          return unless File.exist?(env_file)
+
+          content = File.read(env_file)
+          return if content.include?(MARKER_BEGIN)
+
+          # Only needed for Rails 6+
+          return unless rails_host_authorization_enabled?(app_path)
+
+          injection = <<~RUBY
+
+            #{MARKER_BEGIN}
+            config.hosts << ".ngrok-free.app"
+            config.hosts << ".ngrok.app"
+            #{MARKER_END}
+          RUBY
+
+          updated = content.sub(
+            /Rails\.application\.configure do\s*\n/,
+            "\\0#{injection}"
+          )
+
+          File.write(env_file, updated)
+        end
+
+        def self.remove_ngrok!(app_path)
+          env_file = File.join(app_path, 'config/environments/development.rb')
+          return unless File.exist?(env_file)
+
+          content = File.read(env_file)
+          return unless content.include?(MARKER_BEGIN)
+
+          cleaned = content.sub(
+            /\n\s*#{Regexp.escape(MARKER_BEGIN)}.*?#{Regexp.escape(MARKER_END)}\n/m,
+            "\n"
+          )
+
+          File.write(env_file, cleaned)
+        end
+
+        def self.rails_host_authorization_enabled?(app_path)
+          env_rb = File.join(app_path, 'config/application.rb')
+          return false unless File.exist?(env_rb)
+
+          content = File.read(env_rb)
+          content.include?('config.load_defaults 6') ||
+            content.include?('config.load_defaults 7') ||
+            content.include?('config.load_defaults 8')
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/tunneling/base_provider.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    module Tunneling
+      # Base manager
+      class BaseProvider
+        def expose(_port)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/tunneling/manager.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    module Tunneling
+      # Tunneling manager
+      class Manager
+        def initialize(provider:)
+          @provider = provider.to_sym
+        end
+
+        # Expose the app domain using the correct port
+        def expose_domain(domain, port:, skip_ssl: false)
+          adapter.expose(domain, port: port, skip_ssl: skip_ssl)
+        end
+
+        private
+
+        def adapter
+          case @provider
+          when :ngrok
+            Providers::Ngrok.new
+          when :stable
+            Providers::Stable.new
+          else
+            abort "Unknown tunnel provider: #{@provider}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/tunneling/providers/ngrok.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Stable
+  module Services
+    module Tunneling
+      module Providers
+        # ngrok provider
+        class Ngrok
+          NGROK_API   = 'http://127.0.0.1:4040/api/tunnels'
+          MAX_RETRIES = 10
+          RETRY_DELAY = 0.5
+
+          # Expose the app via ngrok on the app's local port
+          # skip_ssl is kept for future use
+          def expose(domain, port:, skip_ssl: false)
+            return stub_url(domain) if ENV['STABLE_TEST_MODE']
+
+            if (tunnel = existing_tunnel)
+              validate_tunnel!(tunnel, port)
+              return tunnel['public_url']
+            end
+
+            start_ngrok(port)
+            wait_for_url || abort('Failed to obtain ngrok URL')
+          end
+
+          private
+
+          def existing_tunnel
+            resp = JSON.parse(Net::HTTP.get(URI(NGROK_API)))
+            resp['tunnels']&.find { |t| t['proto'] == 'https' }
+          rescue StandardError
+            nil
+          end
+
+          def validate_tunnel!(tunnel, port)
+            target = tunnel.dig('config', 'addr')
+            return if target == "http://localhost:#{port}"
+
+            abort <<~MSG
+              An ngrok tunnel is already running:
+
+                #{tunnel['public_url']} → #{target}
+
+              Free ngrok allows only one tunnel at a time.
+              Stop it first:
+                pkill ngrok
+            MSG
+          end
+
+          def start_ngrok(port)
+            @ngrok_pid = spawn(
+              'ngrok', 'http', port.to_s, '--log=stdout',
+              out: '/dev/null', err: '/dev/null'
+            )
+            Process.detach(@ngrok_pid)
+          end
+
+          def wait_for_url
+            MAX_RETRIES.times do
+              if (tunnel = existing_tunnel)
+                return tunnel['public_url']
+              end
+
+              sleep RETRY_DELAY
+            end
+            nil
+          end
+
+          def stub_url(domain)
+            "https://#{domain}-stable-share.test"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stable/services/tunneling/providers/stable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Stable
+  module Services
+    module Tunneling
+      module Providers
+        # stable provider
+        class Stable
+          # skip_ssl is kept for future use
+          def expose(*)
+            abort 'Stable tunnels are not available yet'
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stable-cli-rails
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.8.5
 platform: ruby
 authors:
 - Danny Simfukwe
@@ -9,6 +9,20 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rqrcode
+  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: thor
   requirement: !ruby/object:Gem::Requirement
@@ -45,29 +59,41 @@ files:
 - lib/stable/commands/remove.rb
 - lib/stable/commands/restart.rb
 - lib/stable/commands/setup.rb
+- lib/stable/commands/share.rb
 - lib/stable/commands/start.rb
 - lib/stable/commands/stop.rb
+- lib/stable/commands/unshare.rb
 - lib/stable/commands/upgrade_ruby.rb
+- lib/stable/commands/workdir.rb
 - lib/stable/config/paths.rb
 - lib/stable/db_manager.rb
 - lib/stable/paths.rb
 - lib/stable/registry.rb
 - lib/stable/scanner.rb
 - lib/stable/services/app_creator.rb
+- lib/stable/services/app_destroyer.rb
+- lib/stable/services/app_opener.rb
 - lib/stable/services/app_registry.rb
 - lib/stable/services/app_remover.rb
 - lib/stable/services/app_restarter.rb
 - lib/stable/services/app_starter.rb
 - lib/stable/services/app_stopper.rb
+- lib/stable/services/app_upgrader.rb
 - lib/stable/services/caddy_manager.rb
+- lib/stable/services/cli/qrcode.rb
 - lib/stable/services/database/base.rb
 - lib/stable/services/database/mysql.rb
 - lib/stable/services/database/postgres.rb
 - lib/stable/services/dependency_checker.rb
 - lib/stable/services/hosts_manager.rb
 - lib/stable/services/process_manager.rb
+- lib/stable/services/rails/host_authorization.rb
 - lib/stable/services/ruby.rb
 - lib/stable/services/setup_runner.rb
+- lib/stable/services/tunneling/base_provider.rb
+- lib/stable/services/tunneling/manager.rb
+- lib/stable/services/tunneling/providers/ngrok.rb
+- lib/stable/services/tunneling/providers/stable.rb
 - lib/stable/system/shell.rb
 - lib/stable/utils/package_manager.rb
 - lib/stable/utils/platform.rb
@@ -92,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Zero-config CLI tool to manage local Rails apps with automatic Caddy and
   HTTPS setup