kitsune-kit 0.4.0 → 0.5.0

data/lib/kitsune/kit/tui/state.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Kitsune
+  module Kit
+    module Tui
+      State = Data.define(
+        :screen, :environment, :resources, :selected_resource, :operations, :logs, :modal, :notification,
+        :running, :terminal_size, :result, :scroll_offset
+      ) do
+        def self.initial(environment:, terminal_size: [100, 30])
+          new(screen: :dashboard, environment: environment, resources: [], selected_resource: 0, operations: [],
+              logs: [], modal: nil, notification: nil, running: false, terminal_size: terminal_size, result: nil,
+              scroll_offset: 0)
+        end
+      end
+    end
+  end
+end

data/lib/kitsune/kit/tui/store.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "state"
+
+module Kitsune
+  module Kit
+    module Tui
+      class Store
+        MAX_LOGS = 200
+
+        def initialize(environment:, secret_filter: SecretFilter.new, terminal_size: [100, 30])
+          @state = State.initial(environment: environment, terminal_size: terminal_size)
+          @secret_filter = secret_filter
+          @mutex = Mutex.new
+        end
+
+        def snapshot = @mutex.synchronize { @state }
+
+        def handle(event)
+          data = @secret_filter.filter(event.data)
+          mutate do |state|
+            operations = update_operations(state.operations, event.type, data)
+            logs = append_log(state.logs, event.type, data)
+            state.with(operations: operations, logs: logs, running: running_for(event.type, state.running),
+                       notification: notification_for(event.type, data, state.notification))
+          end
+        end
+
+        def show(screen, result: nil)
+          mutate { |state| state.with(screen: screen, result: result, modal: nil, scroll_offset: 0) }
+        end
+
+        def resize(width, height) = mutate { |state| state.with(terminal_size: [width, height]) }
+        def select(index) = mutate { |state| state.with(selected_resource: index) }
+        def modal(value) = mutate { |state| state.with(modal: value) }
+        def running(value) = mutate { |state| state.with(running: value) }
+
+        def scroll(delta)
+          mutate do |state|
+            maximum = [state.logs.length - 1, 0].max
+            state.with(scroll_offset: (state.scroll_offset + delta).clamp(0, maximum))
+          end
+        end
+
+        def resources=(values)
+          mutate { |state| state.with(resources: values, selected_resource: 0) }
+        end
+
+        private
+
+        def mutate
+          @mutex.synchronize { @state = yield(@state) }
+        end
+
+        def update_operations(operations, type, data)
+          return operations unless type.start_with?("operation_")
+
+          item = {
+            resource: data[:resource], summary: data[:summary], status: type.delete_prefix("operation_"),
+            duration_ms: data[:duration_ms], message: data[:message], percent: data[:percent]
+          }
+          operations.reject { |operation| operation[:resource] == item[:resource] } + [item]
+        end
+
+        def append_log(logs, type, data)
+          message = data[:message] || data[:summary]
+          return logs unless message
+
+          (logs + ["#{type}: #{message}"]).last(MAX_LOGS)
+        end
+
+        def running_for(type, current)
+          return true if type == "run_started"
+          return false if type == "run_finished"
+
+          current
+        end
+
+        def notification_for(type, data, current)
+          return data[:message] if %w[operation_failed warning_emitted].include?(type)
+          return "Run finished: #{data[:status]}" if type == "run_finished"
+
+          current
+        end
+      end
+    end
+  end
+end

data/lib/kitsune/kit/tui/terminal.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "io/wait"
+
+module Kitsune
+  module Kit
+    module Tui
+      class Terminal
+        ALT_SCREEN = "\e[?1049h"
+        MAIN_SCREEN = "\e[?1049l"
+        DISABLE_WRAP = "\e[?7l"
+        ENABLE_WRAP = "\e[?7h"
+
+        def initialize(input: $stdin, output: $stdout)
+          @input = input
+          @output = output
+        end
+
+        def tty? = input.tty? && output.tty?
+
+        def run
+          raise Errors::ConfigurationError, "the TUI requires an interactive terminal" unless tty?
+
+          enter
+          yield self
+        ensure
+          restore
+        end
+
+        def size
+          rows, columns = output.winsize
+          [columns, rows]
+        rescue SystemCallError, NoMethodError
+          [100, 30]
+        end
+
+        def draw(content)
+          frame = content.lines(chomp: true).each_with_index.map do |line, index|
+            "\e[#{index + 1};1H#{line}"
+          end.join
+          output.write(frame)
+          output.flush
+        end
+
+        def read_key(timeout: 0.1)
+          return unless input.wait_readable(timeout)
+
+          first = input.read_nonblock(1)
+          return first unless first == "\e"
+
+          sequence = first.dup
+          sequence << input.read_nonblock(1) while sequence.length < 6 && input.wait_readable(0.005)
+          { "\e[A" => :up, "\e[B" => :down, "\e[5~" => :page_up, "\e[6~" => :page_down }
+            .fetch(sequence, :escape)
+        rescue IO::WaitReadable
+          nil
+        end
+
+        private
+
+        attr_reader :input, :output
+
+        def enter
+          @original_console_mode = input.console_mode
+          input.raw!
+          @active = true
+          output.write("#{ALT_SCREEN}#{DISABLE_WRAP}\e[?25l\e[2J\e[H")
+          output.flush
+        end
+
+        def restore
+          return unless @active
+
+          restore_console
+          restore_screen
+          @active = false
+        end
+
+        def restore_console
+          input.console_mode = @original_console_mode if @original_console_mode
+        rescue SystemCallError, IOError
+          nil
+        end
+
+        def restore_screen
+          output.write("#{ENABLE_WRAP}\e[?25h#{MAIN_SCREEN}")
+          output.flush
+        rescue SystemCallError, IOError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/kitsune/kit/version.rb

@@ -2,6 +2,6 @@
 
 module Kitsune
   module Kit
-    VERSION = "0.4.0"
+    VERSION = "0.5.0"
   end
 end

data/lib/kitsune/kit/workflows/apply_plan.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../result"
+require_relative "../run_journal"
+require_relative "base"
+
+module Kitsune
+  module Kit
+    module Workflows
+      class ApplyPlan < Base
+        def initialize(config:, operations:, state_store: nil, cancellation: Cancellation.new,
+                       event_bus: Events::NullBus.new, clock: Clock.new)
+          super(config: config, event_bus: event_bus, clock: clock)
+          @operations = operations
+          @cancellation = cancellation
+          @state_store = state_store
+          @journal = RunJournal.new(
+            state_store: state_store,
+            environment: config.environment,
+            run_id: run_id,
+            clock: -> { clock.now }
+          )
+        end
+
+        def call(plan: nil, resume_from: nil)
+          return call_unlocked(plan: plan, resume_from: resume_from) unless @state_store
+
+          @state_store.with_execution_lock(config.environment) do
+            call_unlocked(plan: plan, resume_from: resume_from)
+          end
+        end
+
+        private
+
+        def call_unlocked(plan:, resume_from:)
+          started_at = monotonic_time
+          journal_started = false
+          execution = build_execution(plan, resume_from)
+          emit("run_started", command: "apply", environment: config.environment, resumed_from: execution[:source_id])
+          @journal.start(changes: execution[:changes].map(&:to_h), resumed_from: execution[:source_id])
+          journal_started = true
+          @last_confirmed = nil
+          results = execute(execution)
+          finish("success", started_at)
+          Result.success(results, metadata: { run_id: run_id, resumed_from: execution[:source_id] })
+        rescue StandardError => e
+          if journal_started
+            emit_recovery_guidance
+            finish(failure_status(e), started_at, error: error_code(e))
+          end
+          raise
+        end
+
+        def build_execution(plan, resume_from)
+          return fresh_execution(plan) unless resume_from
+
+          source_id, source = @journal.resumable(resume_from == true ? nil : resume_from)
+          changes = Plan.from_h(environment: config.environment, changes: source["changes"]).changes
+          validate_operation_set!(changes)
+          completed = source["steps"].filter_map { |resource, step| resource if step["status"] == "success" }
+          { source_id: source_id, changes: changes, completed: completed }
+        end
+
+        def fresh_execution(plan)
+          changes = plan ? plan.changes : @operations.map(&:plan)
+          validate_operation_set!(changes)
+          { source_id: nil, changes: changes, completed: [] }
+        end
+
+        def validate_operation_set!(changes)
+          operation_resources = @operations.map(&:resource)
+          change_resources = changes.map(&:resource)
+          return if operation_resources == change_resources
+
+          raise Errors::ConfigurationError.new(
+            "the saved plan does not match the configured operations",
+            hint: "Review the configuration and start a new `kit plan` and `kit apply`."
+          )
+        end
+
+        def execute(execution)
+          execution[:changes].each_with_index.map do |change, index|
+            if execution[:completed].include?(change.resource)
+              emit("operation_skipped", resource: change.resource, summary: change.summary,
+                                        reason: "already_completed")
+              next
+            end
+
+            execute_change(operation_for(change), change, index: index + 1, total: execution[:changes].length)
+          end
+        end
+
+        def execute_change(operation, change, index:, total:)
+          @cancellation.check!
+          started_at = monotonic_time
+          @journal.record_step(change.resource, "running")
+          emit("operation_started", resource: change.resource, summary: change.summary, action: change.action,
+                                    index: index, total: total)
+          emit("operation_progressed", resource: change.resource, summary: change.summary, action: change.action,
+                                       percent: 0)
+          operation.apply(change).tap do
+            @journal.record_step(change.resource, "success")
+            @last_confirmed = change.resource
+            emit("operation_progressed", resource: change.resource, summary: change.summary, action: change.action,
+                                         percent: 100)
+            emit_success(change, started_at)
+          end
+        rescue StandardError => e
+          @journal.record_step(change.resource, "failure", error: error_code(e))
+          emit_failure(change, e)
+          raise
+        end
+
+        def operation_for(change) = @operations.find { |operation| operation.resource == change.resource }
+
+        def emit_success(change, started_at)
+          emit("operation_succeeded", resource: change.resource, summary: change.summary, action: change.action,
+                                      duration_ms: elapsed_ms(started_at))
+        end
+
+        def emit_failure(change, error)
+          emit("operation_failed", resource: change.resource, summary: change.summary,
+                                   message: error.message, code: error_code(error))
+        end
+
+        def finish(status, started_at, error: nil)
+          @journal.finish(status, error: error)
+          emit("run_finished", status: status, duration_ms: elapsed_ms(started_at))
+        end
+
+        def error_code(error) = error.respond_to?(:code) ? error.code : "unexpected_error"
+        def failure_status(error) = error.is_a?(Cancellation::Cancelled) ? "cancelled" : "failure"
+
+        def emit_recovery_guidance
+          confirmed = @last_confirmed ? " Last confirmed step: #{@last_confirmed}." : " No step was confirmed."
+          emit(
+            "warning_emitted",
+            message: "Run #{run_id} is incomplete.#{confirmed} Correct the cause, then run `kit resume #{run_id}`."
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kitsune/kit/workflows/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../clock"
+require_relative "../events"
+
+module Kitsune
+  module Kit
+    module Workflows
+      class Base
+        def initialize(config:, event_bus: Events::NullBus.new, clock: Clock.new)
+          @config = config
+          @event_bus = event_bus
+          @clock = clock
+          @run_id = SecureRandom.uuid
+        end
+
+        private
+
+        attr_reader :config, :event_bus, :run_id, :clock
+
+        def emit(type, **data)
+          event_bus.publish(Events::Event.build(type, run_id: run_id, time: clock.now, **data))
+        end
+
+        def monotonic_time = clock.monotonic
+        def elapsed_ms(started_at) = ((monotonic_time - started_at) * 1000).round
+      end
+    end
+  end
+end

data/lib/kitsune/kit/workflows/build_plan.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../plan"
+require_relative "../result"
+require_relative "base"
+
+module Kitsune
+  module Kit
+    module Workflows
+      class BuildPlan < Base
+        def initialize(config:, operations:, event_bus: Events::NullBus.new, clock: Clock.new)
+          super(config: config, event_bus: event_bus, clock: clock)
+          @operations = operations
+        end
+
+        def call
+          started_at = monotonic_time
+          emit("run_started", command: "plan", environment: config.environment)
+          changes = @operations.map(&:plan)
+          plan = Plan.new(environment: config.environment, changes: changes)
+          emit(
+            "plan_built",
+            changed_count: plan.changed_count,
+            unchanged_count: plan.changes.length - plan.changed_count,
+            destructive: plan.destructive?
+          )
+          emit("run_finished", status: "success", duration_ms: elapsed_ms(started_at))
+          Result.success(plan, metadata: { run_id: run_id })
+        end
+      end
+    end
+  end
+end

data/lib/kitsune/kit/workflows/destroy_server.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../result"
+require_relative "base"
+
+module Kitsune
+  module Kit
+    module Workflows
+      class DestroyServer < Base
+        def initialize(config:, provider:, state_store:, dns_operation: nil, event_bus: Events::NullBus.new,
+                       clock: Clock.new)
+          super(config: config, event_bus: event_bus, clock: clock)
+          @provider = provider
+          @state_store = state_store
+          @dns_operation = dns_operation
+        end
+
+        def call(confirmation:)
+          @state_store.with_execution_lock(config.environment) { call_unlocked(confirmation: confirmation) }
+        end
+
+        private
+
+        def call_unlocked(confirmation:)
+          state = @state_store.read(config.environment)
+          managed = state.dig("resources", "server")
+          unless managed&.fetch("id", nil)
+            raise Errors::UnsafeOperationError.new(
+              "no managed server ID exists in state",
+              hint: "Import and verify the server before attempting destruction."
+            )
+          end
+          validate_confirmation!(confirmation, managed)
+          current = verify_exact_server!(managed)
+          started_at = monotonic_time
+          emit("run_started", command: "server.destroy", environment: config.environment)
+          @provider.delete_server(id: managed.fetch("id")) if current
+          @dns_operation&.rollback
+          record_destruction(managed.fetch("id"))
+          emit("run_finished", status: "success", duration_ms: elapsed_ms(started_at))
+          Result.success(managed.fetch("id"), metadata: { run_id: run_id })
+        rescue StandardError
+          emit("run_finished", status: "failure", duration_ms: 0) if defined?(started_at) && started_at
+          raise
+        end
+
+        def validate_confirmation!(confirmation, managed)
+          return if confirmation == config.server.name
+
+          raise Errors::UnsafeOperationError.new(
+            "server destruction was not confirmed",
+            hint: "Pass --confirm-destroy #{config.server.name} after reviewing the environment.",
+            context: {
+              provider: config.provider.name, environment: config.environment,
+              server: config.server.name, provider_id: managed["id"], recoverable: false
+            }
+          )
+        end
+
+        def verify_exact_server!(managed)
+          current = @provider.find_server_by_id(id: managed.fetch("id"))
+          return unless current
+
+          expected_tags = config.server.tags
+          return current if current.name == config.server.name && (expected_tags - current.tags).empty?
+
+          raise Errors::UnsafeOperationError.new(
+            "managed provider ID points to an unexpected server",
+            hint: "Do not delete by name. Reconcile or import state first."
+          )
+        end
+
+        def record_destruction(id)
+          @state_store.update(config.environment) do |state|
+            state["resources"].clear
+            state["operations"] << { "resource" => "server", "action" => "destroy", "status" => "applied", "id" => id }
+            state
+          end
+        end
+      end
+    end
+  end
+end