kitsune-kit 0.4.1 → 0.6.0

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require_relative "../errors"
+
+module Kitsune
+  module Kit
+    module Workflows
+      class InitializeProject
+        CONFIG = <<~YAML
+          version: 1
+          provider:
+            name: digitalocean
+            token_env: DO_API_TOKEN
+
+          server:
+            name: myapp-development
+            region: sfo3
+            size: s-1vcpu-1gb
+            image: ubuntu-24-04-x64
+            ssh_key_id: replace-with-digitalocean-key-id
+            tags:
+              - kitsune-managed
+
+          ssh:
+            user: deploy
+            port: 22
+            key_path: ~/.ssh/id_ed25519
+            allowed_cidrs: []
+
+          services:
+            postgres:
+              enabled: false
+              mode: managed
+              host:
+              image: postgres:17
+              publish: false
+              bind: 127.0.0.1
+              allowed_cidrs: []
+              port: 5432
+              password_env: POSTGRES_PASSWORD
+              compose:
+                mode: generated
+                file:
+                allow_unsafe: false
+            redis:
+              enabled: false
+              mode: managed
+              host:
+              image: redis:7.2
+              publish: false
+              bind: 127.0.0.1
+              allowed_cidrs: []
+              port: 6379
+              password_env: REDIS_PASSWORD
+              compose:
+                mode: generated
+                file:
+                allow_unsafe: false
+
+          system:
+            swap_size_gb: 2
+            swap_swappiness: 10
+            unattended_upgrades: true
+            metrics: false
+            metrics_installer_sha256:
+
+          dns:
+            domains: []
+            ttl: 3600
+        YAML
+
+        ENVIRONMENT = <<~YAML
+          version: 1
+          server:
+            name: myapp-development
+        YAML
+
+        def initialize(root: Dir.pwd)
+          @root = Pathname(root).expand_path
+        end
+
+        def call(force: false)
+          base = @root.join(".kitsune")
+          files = {
+            base.join("config.yml") => CONFIG,
+            base.join("environments/development.yml") => ENVIRONMENT,
+            base.join("environment") => "development\n"
+          }
+          existing = files.keys.select(&:exist?)
+          if existing.any? && !force
+            raise Errors::UnsafeOperationError.new(
+              "Kitsune Kit configuration already exists",
+              hint: "Use `kit init --force` only if replacing these files is intentional.",
+              context: { files: existing.map(&:to_s) }
+            )
+          end
+
+          files.each do |path, content|
+            FileUtils.mkdir_p(path.dirname, mode: 0o700)
+            path.write(content)
+            File.chmod(0o600, path)
+          end
+          ensure_gitignore
+          files.keys.map(&:to_s)
+        end
+
+        private
+
+        def ensure_gitignore
+          path = @root.join(".gitignore")
+          lines = path.file? ? path.readlines(chomp: true) : []
+          additions = [
+            "/.kitsune/state/",
+            "/.kitsune/logs/",
+            "/.kitsune/support/",
+            "/.kitsune/environment",
+            "/.kitsune/known_hosts"
+          ] - lines
+          return if additions.empty?
+
+          separator = lines.empty? || lines.last.empty? ? "" : "\n"
+          File.open(path, "a", 0o644) { |file| file.write("#{separator}#{additions.join("\n")}\n") }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+require_relative "base"
+
+module Kitsune
+  module Kit
+    module Workflows
+      EnvironmentStatus = Data.define(:environment, :server, :managed_resources, :last_operations) do
+        def to_h
+          {
+            environment: environment,
+            server: server&.to_h,
+            managed_resources: managed_resources,
+            last_operations: last_operations
+          }
+        end
+      end
+
+      class InspectEnvironment < Base
+        def initialize(config:, provider:, state_store:, event_bus: Events::NullBus.new, clock: Clock.new)
+          super(config: config, event_bus: event_bus, clock: clock)
+          @provider = provider
+          @state_store = state_store
+        end
+
+        def call
+          started_at = monotonic_time
+          emit("run_started", command: "inspect", environment: config.environment)
+          state = @state_store.read(config.environment)
+          server = @provider.find_server(name: config.server.name, tags: config.server.tags)
+          value = EnvironmentStatus.new(
+            environment: config.environment,
+            server: server,
+            managed_resources: state["resources"],
+            last_operations: state["operations"].last(20)
+          )
+          emit("run_finished", status: "success", duration_ms: elapsed_ms(started_at))
+          Result.success(value, metadata: { run_id: run_id })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+require_relative "base"
+
+module Kitsune
+  module Kit
+    module Workflows
+      class Rollback < Base
+        def initialize(config:, operations:, state_store: nil, event_bus: Events::NullBus.new, clock: Clock.new)
+          super(config: config, event_bus: event_bus, clock: clock)
+          @operations = operations
+          @state_store = state_store
+        end
+
+        def call
+          return call_unlocked unless @state_store
+
+          @state_store.with_execution_lock(config.environment) { call_unlocked }
+        end
+
+        private
+
+        def call_unlocked
+          started_at = monotonic_time
+          emit("run_started", command: "rollback", environment: config.environment)
+          rolled_back = @operations.reverse.filter_map { |operation| rollback_operation(operation) }
+          emit("run_finished", status: "success", duration_ms: elapsed_ms(started_at))
+          Result.success(rolled_back, metadata: { run_id: run_id })
+        rescue StandardError
+          emit("run_finished", status: "failure", duration_ms: elapsed_ms(started_at))
+          raise
+        end
+
+        def rollback_operation(operation)
+          return unless operation.respond_to?(:rollback)
+
+          started_at = monotonic_time
+          emit("operation_started", resource: operation.resource, summary: "Rollback #{operation.resource}",
+                                    action: "rollback")
+          changed = operation.rollback
+          emit(
+            "operation_succeeded",
+            resource: operation.resource,
+            summary: changed ? "Rolled back #{operation.resource}" : "#{operation.resource} was not managed",
+            action: "rollback",
+            duration_ms: elapsed_ms(started_at)
+          )
+          operation.resource if changed
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "pathname"
+require "rbconfig"
+require "securerandom"
+require "time"
+
+module Kitsune
+  module Kit
+    module Workflows
+      class SupportBundle
+        MAX_LOG_FILES = 5
+        MAX_LOG_LINES = 500
+
+        def initialize(root:, config:, state_store:, doctor:, secret_filter: SecretFilter.new,
+                       clock: -> { Time.now.utc })
+          @root = Pathname(root).expand_path
+          @config = config
+          @state_store = state_store
+          @doctor = doctor
+          @secret_filter = secret_filter
+          @clock = clock
+        end
+
+        def call
+          directory = root.join(".kitsune/support")
+          FileUtils.mkdir_p(directory, mode: 0o700)
+          path = directory.join("#{clock.call.strftime('%Y%m%dT%H%M%S')}-#{SecureRandom.hex(4)}.json")
+          path.write(JSON.pretty_generate(secret_filter.filter(payload)) << "\n")
+          File.chmod(0o600, path)
+          path.to_s
+        end
+
+        private
+
+        attr_reader :root, :config, :state_store, :doctor, :secret_filter, :clock
+
+        def payload
+          {
+            schema_version: 1,
+            generated_at: clock.call.iso8601(6),
+            kitsune_version: VERSION,
+            ruby: { version: RUBY_VERSION, platform: RUBY_PLATFORM, host_os: RbConfig::CONFIG["host_os"] },
+            configuration: serialize(config),
+            state: state_store.read(config.environment),
+            doctor: doctor.call.value.map(&:to_h),
+            logs: selected_logs
+          }
+        end
+
+        def selected_logs
+          directory = root.join(".kitsune/logs")
+          return [] unless directory.directory?
+
+          directory.glob("*.jsonl").sort_by(&:mtime).last(MAX_LOG_FILES).map do |path|
+            { file: path.basename.to_s, events: read_log(path) }
+          end
+        end
+
+        def read_log(path)
+          path.readlines.last(MAX_LOG_LINES).filter_map do |line|
+            JSON.parse(line)
+          rescue JSON::ParserError
+            { "type" => "invalid_log_line", "message" => "A local log line could not be parsed." }
+          end
+        rescue SystemCallError => e
+          [{ "type" => "log_read_error", "message" => e.class.name }]
+        end
+
+        def serialize(value)
+          return value.members.to_h { |member| [member, serialize(value.public_send(member))] } if value.is_a?(Data)
+          return value.to_h { |key, item| [key, serialize(item)] } if value.is_a?(Hash)
+          return value.map { |item| serialize(item) } if value.is_a?(Array)
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/kitsune/kit.rb

@@ -1,10 +1,50 @@
 # frozen_string_literal: true
 
 require_relative "kit/version"
+require_relative "kit/errors"
+require_relative "kit/events"
+require_relative "kit/result"
+require_relative "kit/plan"
+require_relative "kit/secret_filter"
+require_relative "kit/secret_store"
+require_relative "kit/clock"
+require_relative "kit/cancellation"
+require_relative "kit/run_logger"
+require_relative "kit/run_journal"
+require_relative "kit/service_compose"
+require_relative "kit/configuration"
+require_relative "kit/state_store"
+require_relative "kit/adapters/fake_state_store"
+require_relative "kit/adapters/fake_reporter"
+require_relative "kit/adapters/fake_secret_store"
+require_relative "kit/adapters/fake_clock"
+require_relative "kit/application"
+require_relative "kit/operations/ensure_dns_records"
+require_relative "kit/operations/remote_script"
+require_relative "kit/operations/ensure_service"
+require_relative "kit/reporters/human"
+require_relative "kit/reporters/json"
+require_relative "kit/workflows/build_plan"
+require_relative "kit/workflows/apply_plan"
+require_relative "kit/workflows/doctor"
+require_relative "kit/workflows/initialize_project"
+require_relative "kit/workflows/eject_compose"
+require_relative "kit/workflows/inspect_environment"
+require_relative "kit/workflows/rollback"
+require_relative "kit/workflows/destroy_server"
+require_relative "kit/workflows/import_server"
+require_relative "kit/workflows/environment_selection"
+require_relative "kit/workflows/support_bundle"
+require_relative "kit/tui/state"
+require_relative "kit/tui/store"
+require_relative "kit/tui/renderer"
+require_relative "kit/tui/terminal"
+require_relative "kit/tui/actions"
+require_relative "kit/tui/controller"
+require_relative "kit/tui/application"
 
 module Kitsune
   module Kit
-    class Error < StandardError; end
-    # Your code goes here...
+    Error = Errors::Error
   end
 end