odysseus-cli 0.2.0 → 0.3.0

data/lib/odysseus/cli/ui.rb

@@ -0,0 +1,447 @@
+# odysseus-cli/lib/odysseus/cli/ui.rb
+#
+# Terminal UI renderer for Odysseus CLI.
+#
+# Default mode: numbered steps with animated spinners that resolve to ✓/✗.
+# Debug mode (--debug): verbose plain-text output, no spinners.
+
+module Odysseus
+  module CLI
+    # IO wrapper that redacts sensitive values before writing
+    class RedactingIO
+      def initialize(io, redact_fn)
+        @io = io
+        @redact = redact_fn
+      end
+
+      def write(str)
+        @io.write(@redact.call(str.to_s))
+      end
+
+      def puts(*args)
+        args.each { |a| @io.puts(@redact.call(a.to_s)) }
+        @io.puts if args.empty?
+      end
+
+      def print(*args)
+        args.each { |a| @io.print(@redact.call(a.to_s)) }
+      end
+
+      def flush
+        @io.flush
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @io.respond_to?(method, include_private)
+      end
+
+      def method_missing(method, *args, &block)
+        @io.send(method, *args, &block)
+      end
+    end
+
+    class UI
+      SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+
+      # ANSI color helpers
+      COPPER  = "\e[38;2;255;183;123m".freeze
+      MINT    = "\e[38;2;112;216;200m".freeze
+      RED     = "\e[38;2;255;100;100m".freeze
+      DIM     = "\e[2m".freeze
+      RESET   = "\e[0m".freeze
+
+      def initialize(debug: false)
+        @debug = debug
+        @step_number = 0
+      end
+
+      def debug?
+        @debug
+      end
+
+      def reset_steps!
+        @step_number = 0
+      end
+
+      def next_step!
+        @step_number += 1
+      end
+
+      # --- Header ---
+
+      def header(title)
+        reset_steps!
+        if debug?
+          puts "\e[36m#{title}\e[0m"
+        else
+          puts ""
+          puts "  #{COPPER}#{title}#{RESET}"
+        end
+      end
+
+      def info(label, value)
+        if debug?
+          puts "  #{label}: #{value}"
+        else
+          puts "  #{DIM}#{label}:#{RESET} #{value}"
+        end
+      end
+
+      def blank
+        puts ""
+      end
+
+      # --- Single spin step ---
+      # Shows spinner while block runs, resolves to ✓/✗.
+      # Captures stdout from the block so it doesn't leak.
+
+      def spin_step(message)
+        next_step!
+        num = step_num_str
+
+        if debug?
+          puts "  #{num}  #{redact(message)}"
+          result = yield
+          puts "  #{num}  ✓ #{redact(message)}"
+          return result
+        end
+
+        result = nil
+        err = nil
+        done = false
+
+        # Capture stdout from the block
+        old_stdout = $stdout
+        rd, wr = IO.pipe
+        $stdout = wr
+
+        thread = Thread.new do
+          begin
+            result = yield
+          rescue => e
+            err = e
+          ensure
+            done = true
+            wr.close
+          end
+        end
+
+        frame_idx = 0
+        loop do
+          break if done
+          frame = SPINNER_FRAMES[frame_idx % SPINNER_FRAMES.size]
+          old_stdout.print "\r  #{DIM}#{num}#{RESET}  #{COPPER}#{frame}#{RESET}  #{message}"
+          old_stdout.flush
+          frame_idx += 1
+          sleep 0.08
+        end
+
+        rd.close
+        $stdout = old_stdout
+        thread.join
+
+        print "\r\e[K"
+
+        if err
+          puts "  #{DIM}#{num}#{RESET}  #{RED}✗#{RESET}  #{message}"
+          raise err
+        else
+          puts "  #{DIM}#{num}#{RESET}  #{MINT}✓#{RESET}  #{message}"
+        end
+
+        result
+      end
+
+      # --- Streaming steps ---
+      # Runs a block, captures its stdout line by line, and renders each
+      # meaningful line as a sub-step with spinner → ✓.
+      # All sub-steps share the same step number.
+
+      def stream_steps(title: nil)
+        next_step!
+        num = step_num_str
+
+        if debug?
+          puts "  #{num}  > #{title}" if title
+          # In debug mode, let output flow but redact sensitive values
+          old_stdout = $stdout
+          $stdout = RedactingIO.new(old_stdout, method(:redact))
+          begin
+            yield
+          ensure
+            $stdout = old_stdout
+          end
+          return
+        end
+
+        # Show section header if provided
+        puts "  #{DIM}#{num}#{RESET}  #{COPPER}>#{RESET}  #{title}" if title
+
+        result = nil
+        err = nil
+        done = false
+        current_line = nil
+
+        # Capture stdout
+        old_stdout = $stdout
+        rd, wr = IO.pipe
+
+        thread = Thread.new do
+          $stdout = wr
+          begin
+            result = yield
+          rescue => e
+            err = e
+          ensure
+            done = true
+            wr.close
+          end
+        end
+
+        frame_idx = 0
+        buf = ""
+
+        loop do
+          # Non-blocking read from pipe
+          begin
+            chunk = rd.read_nonblock(4096)
+            buf << chunk
+          rescue IO::WaitReadable
+            # No data available yet
+          rescue EOFError
+            break
+          end
+
+          # Process complete lines
+          while (nl = buf.index("\n"))
+            line = buf.slice!(0..nl).strip
+            next if line.empty?
+            line = clean_line(line)
+            next unless line
+
+            # Note lines (prefixed with ~) render as indented grey text, no spinner
+            if line.start_with?('~')
+              if current_line
+                old_stdout.print "\r\e[K"
+                old_stdout.puts "  #{DIM}#{num}#{RESET}  #{MINT}✓#{RESET}  #{current_line}"
+                current_line = nil
+              end
+              old_stdout.puts "  #{DIM}#{num}#{RESET}     #{DIM}#{line[1..]}#{RESET}"
+              next
+            end
+
+            # Resolve previous sub-step
+            if current_line
+              old_stdout.print "\r\e[K"
+              old_stdout.puts "  #{DIM}#{num}#{RESET}  #{MINT}✓#{RESET}  #{current_line}"
+            end
+
+            current_line = line
+          end
+
+          # Animate spinner on current line
+          if current_line
+            frame = SPINNER_FRAMES[frame_idx % SPINNER_FRAMES.size]
+            old_stdout.print "\r  #{DIM}#{num}#{RESET}  #{COPPER}#{frame}#{RESET}  #{current_line}"
+            old_stdout.flush
+          end
+
+          frame_idx += 1
+          sleep 0.06
+
+          break if done && buf.empty?
+        end
+
+        rd.close
+        $stdout = old_stdout
+        thread.join
+
+        # Resolve the final sub-step
+        if current_line
+          print "\r\e[K"
+          puts "  #{DIM}#{num}#{RESET}  #{MINT}✓#{RESET}  #{current_line}"
+        end
+
+        raise err if err
+        result
+      end
+
+      # --- Immediate steps (no async) ---
+
+      def step_ok(message)
+        next_step!
+        puts "  #{DIM}#{step_num_str}#{RESET}  #{MINT}✓#{RESET}  #{message}"
+      end
+
+      def step_fail(message)
+        next_step!
+        puts "  #{DIM}#{step_num_str}#{RESET}  #{RED}✗#{RESET}  #{message}"
+      end
+
+      def step_info(message)
+        next_step!
+        puts "  #{DIM}#{step_num_str}#{RESET}  #{COPPER}➜#{RESET}  #{message}"
+      end
+
+      # --- Simple output (no numbering) ---
+
+      def success(message)
+        puts "  #{MINT}✓#{RESET} #{message}"
+      end
+
+      def error(message)
+        puts "  #{RED}✗#{RESET} #{message}"
+      end
+
+      def warn(message)
+        puts "  \e[33m!#{RESET} #{message}"
+      end
+
+      def step(message)
+        if debug?
+          puts "  #{redact(message)}"
+        else
+          puts "  #{DIM}›#{RESET} #{message}"
+        end
+      end
+
+      def detail(message)
+        puts "    #{DIM}#{redact(message)}#{RESET}" if debug?
+      end
+
+      # --- Tables ---
+
+      def table(headers:, rows:)
+        return if rows.empty?
+
+        widths = headers.map.with_index do |h, i|
+          [h.to_s.length, rows.map { |r| r[i].to_s.length }.max || 0].max
+        end
+
+        header_line = headers.map.with_index { |h, i| h.to_s.ljust(widths[i]) }.join("  ")
+        puts "  #{COPPER}#{header_line}#{RESET}"
+        puts "  #{widths.map { |w| '─' * w }.join('  ')}"
+
+        rows.each do |row|
+          line = row.map.with_index { |c, i| c.to_s.ljust(widths[i]) }.join("  ")
+          puts "  #{line}"
+        end
+      end
+
+      # --- Section divider ---
+
+      def section(title)
+        if debug?
+          puts "\e[36m=== #{title} ===\e[0m"
+        else
+          puts "  #{COPPER}▸ #{title}#{RESET}"
+        end
+      end
+
+      # --- Deploy-specific helpers ---
+
+      def deploy_header(service:, image:, image_tag:, build: false, distribution: nil)
+        header "Odysseus Deploy"
+        info "Service", service
+        info "Image", "#{image}:#{image_tag}"
+        info "Distribute", distribution if build && distribution
+        blank
+      end
+
+      def deploy_complete(duration: nil)
+        msg = "Deployment successful"
+        msg += " in #{duration}s" if duration
+        step_ok msg
+      end
+
+      # --- Logger adapter ---
+
+      def build_logger
+        ui = self
+        Object.new.tap do |l|
+          l.define_singleton_method(:info) { |msg| ui.step(msg) }
+          l.define_singleton_method(:warn) { |msg| ui.warn(msg) }
+          l.define_singleton_method(:error) { |msg| ui.error(msg) }
+          l.define_singleton_method(:debug) { |msg| ui.detail(msg) }
+          l.define_singleton_method(:verbose?) { ui.debug? }
+        end
+      end
+
+      private
+
+      def step_num_str
+        format('%02d', @step_number)
+      end
+
+      # Redact sensitive values from output.
+      # Matches common patterns for API keys, tokens, passwords, and secrets
+      # passed as env vars or command flags.
+      def redact(text)
+        text
+          .gsub(/(-e\s+\w*(?:KEY|TOKEN|SECRET|PASSWORD|MASTER_KEY|API_KEY|CREDENTIALS)\s*=\s*)\S+/i, '\1[REDACTED]')
+          .gsub(/((?:KEY|TOKEN|SECRET|PASSWORD|MASTER_KEY|API_KEY|CREDENTIALS)\s*[=:]\s*)\S+/i, '\1[REDACTED]')
+          .gsub(/(-p\s+)\S+/, '\1[REDACTED]')
+          .gsub(/(--password\s+)\S+/, '\1[REDACTED]')
+      end
+
+      # Clean up raw output lines from core orchestrators.
+      # Returns nil for lines we should skip.
+      def clean_line(line)
+        # Strip leading whitespace
+        line = line.sub(/^\s+/, '')
+
+        # Skip empty / decorative / noise
+        return nil if line.empty?
+        return nil if line.start_with?('===', '---', '[WARN]', '[ERROR]')
+
+        # Skip verbose detail lines
+        return nil if line.match?(/^Image: /)
+        return nil if line.match?(/^Environment: /)
+        return nil if line.match?(/^Resources: /)
+        return nil if line.match?(/^Volumes: /)
+        return nil if line.match?(/^Found \d+ existing container/)
+        return nil if line.match?(/^Deploying .+ \(role: .+\)/)
+        return nil if line.match?(/^Building locally/)
+        return nil if line.match?(/^Pushing image via SSH to/)
+        return nil if line.match?(/^Deploy complete for /)
+        return nil if line.match?(/^Rolling deploy complete/)
+
+        # Skip "done" echo lines — the spinner→✓ already shows completion
+        return nil if line.match?(/^Container started: /)
+        return nil if line.match?(/^Health check passed$/)
+        return nil if line.match?(/^Caddy routing configured$/)
+        return nil if line.match?(/^Old container removed$/)
+        return nil if line.match?(/^Image pulled$/)
+        return nil if line.match?(/^Attached to proxy$/)
+
+        # Note lines — indented grey text under the previous step
+        return '~Caddy already running' if line.match?(/^Caddy already running$/)
+        return '~Caddy started' if line.match?(/^Caddy started$/)
+        return '~Caddy is ready' if line.match?(/^Caddy is ready$/)
+
+        # Map known messages to clean versions
+        CLEAN_MESSAGES.each do |pattern, replacement|
+          if line.match?(pattern)
+            return line.sub(pattern, replacement)
+          end
+        end
+
+        line
+      end
+
+      CLEAN_MESSAGES = {
+        /^Ensuring Caddy proxy is running\.\.\./ => 'Starting Caddy',
+        /^Starting new container\.\.\.$/ => 'Starting container',
+        /^Waiting for health check.*/ => 'Health check',
+        /^Adding to Caddy proxy.*/ => 'Caddy route update',
+        /^Draining old container.*/ => 'Draining old container',
+        /^Pulling image\.\.\.$/ => 'Pulling image',
+        /^Building image: .+$/ => 'Building image',
+        /^Pushing to (.+)\.\.\./ => 'Pushing image to \1',
+        /^Starting (.+)\.\.\.$/ => 'Starting \1',
+        /^Stopping (.+) .*/ => 'Stopping \1',
+        /^Attaching (.+) to proxy.*/ => 'Attaching \1 to proxy',
+      }.freeze
+    end
+  end
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: odysseus-cli
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
-- Your Name
+- Thomas
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -24,19 +24,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: pastel
+  name: ratatui_ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -67,7 +67,7 @@ dependencies:
         version: '3.10'
 description: Command-line interface for deploying with Odysseus
 email:
-- your@email.com
+- thomas@imfiny.com
 executables:
 - odysseus
 extensions: []
@@ -76,8 +76,8 @@ files:
 - README.md
 - bin/odysseus
 - lib/odysseus/cli/cli.rb
-- lib/odysseus/cli/gum.rb
-homepage: https://github.com/WaSystems/odysseus
+- lib/odysseus/cli/ui.rb
+homepage: https://github.com/WA-Systems-EU/odysseus
 licenses:
 - LGPL-3.0-only
 metadata: {}

data/lib/odysseus/cli/gum.rb

@@ -1,156 +0,0 @@
-# odysseus-cli/lib/odysseus/cli/gum.rb
-# Wrapper for Charm's gum CLI tool
-# https://github.com/charmbracelet/gum
-
-require 'open3'
-require 'tempfile'
-
-module Odysseus
-  module CLI
-    module Gum
-      class << self
-        # Check if gum is installed and available
-        def available?
-          @available ||= system('which gum > /dev/null 2>&1')
-        end
-
-        # Display a spinner while executing a block
-        # Returns the block's result
-        def spin(title:, spinner: 'dot')
-          return yield unless available?
-
-          result = nil
-          error = nil
-
-          # We can't use gum spin directly with Ruby blocks, so we show spinner
-          # and run the block in a thread
-          spin_pid = spawn("gum spin --spinner #{spinner} --title #{shell_escape(title)} -- sleep infinity",
-                           out: '/dev/null', err: '/dev/null')
-
-          begin
-            result = yield
-          rescue => e
-            error = e
-          ensure
-            Process.kill('TERM', spin_pid) rescue nil
-            Process.wait(spin_pid) rescue nil
-          end
-
-          raise error if error
-          result
-        end
-
-        # Interactive selection menu
-        # Returns selected option or nil if cancelled
-        def choose(options, header: nil)
-          return nil unless available?
-
-          args = ['gum', 'choose']
-          args += ['--header', header] if header
-          args += options
-
-          stdout, status = Open3.capture2(*args)
-          return nil unless status.success?
-
-          stdout.strip
-        end
-
-        # Yes/No confirmation dialog
-        # Returns true for yes, false for no
-        def confirm(message)
-          return true unless available?
-
-          system('gum', 'confirm', message)
-        end
-
-        # Style text with borders, colors, padding
-        def style(text, border: nil, foreground: nil, background: nil, padding: nil, margin: nil, bold: false)
-          return text unless available?
-
-          args = ['gum', 'style']
-          args += ['--border', border] if border
-          args += ['--foreground', foreground.to_s] if foreground
-          args += ['--background', background.to_s] if background
-          args += ['--padding', padding.to_s] if padding
-          args += ['--margin', margin.to_s] if margin
-          args << '--bold' if bold
-          args << text
-
-          stdout, status = Open3.capture2(*args)
-          status.success? ? stdout : text
-        end
-
-        # Display a table from headers and rows
-        # Returns formatted table string
-        def table(headers:, rows:)
-          return simple_table(headers, rows) unless available?
-
-          # gum table reads CSV from stdin
-          csv_data = [headers.join(',')]
-          rows.each do |row|
-            csv_data << row.map { |cell| csv_escape(cell.to_s) }.join(',')
-          end
-
-          stdout, status = Open3.capture2('gum', 'table', stdin_data: csv_data.join("\n"))
-          status.success? ? stdout : simple_table(headers, rows)
-        end
-
-        # Format text (markdown, code, etc.)
-        def format(text, type: 'markdown')
-          return text unless available?
-
-          stdout, status = Open3.capture2('gum', 'format', '-t', type, stdin_data: text)
-          status.success? ? stdout : text
-        end
-
-        # Display a log message with level styling
-        def log(message, level: 'info')
-          return puts(message) unless available?
-
-          system('gum', 'log', '-l', level, message)
-        end
-
-        # Join multiple styled blocks horizontally or vertically
-        def join(*texts, horizontal: false)
-          return texts.join("\n") unless available?
-
-          args = ['gum', 'join']
-          args << '--horizontal' if horizontal
-          args += texts
-
-          stdout, status = Open3.capture2(*args)
-          status.success? ? stdout : texts.join(horizontal ? ' ' : "\n")
-        end
-
-        private
-
-        def shell_escape(str)
-          "'#{str.gsub("'", "'\\\\''")}'"
-        end
-
-        def csv_escape(str)
-          if str.include?(',') || str.include?('"') || str.include?("\n")
-            "\"#{str.gsub('"', '""')}\""
-          else
-            str
-          end
-        end
-
-        # Fallback simple table for when gum is not available
-        def simple_table(headers, rows)
-          widths = headers.map.with_index do |h, i|
-            [h.to_s.length, rows.map { |r| r[i].to_s.length }.max || 0].max
-          end
-
-          lines = []
-          lines << headers.map.with_index { |h, i| h.to_s.ljust(widths[i]) }.join('  ')
-          lines << widths.map { |w| '-' * w }.join('  ')
-          rows.each do |row|
-            lines << row.map.with_index { |c, i| c.to_s.ljust(widths[i]) }.join('  ')
-          end
-          lines.join("\n")
-        end
-      end
-    end
-  end
-end