pvectl 0.2.0

data/lib/pvectl/config/store.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Pvectl
+  module Config
+    # Handles YAML configuration file persistence.
+    #
+    # Store manages saving configuration to YAML files with proper
+    # secure file permissions. It ensures config files are created
+    # with mode 0600 (owner read/write only) and directories with
+    # mode 0700 (owner access only).
+    #
+    # @example Saving configuration
+    #   store = Store.new
+    #   store.save("~/.pvectl/config", config_hash)
+    #
+    # @example Updating current context
+    #   store.update_current_context("~/.pvectl/config", "production")
+    #
+    class Store
+      # Secure file permissions (owner read/write only)
+      SECURE_MODE = 0o600
+
+      # Secure directory permissions (owner access only)
+      SECURE_DIR_MODE = 0o700
+
+      # Saves configuration to a YAML file with secure permissions.
+      #
+      # Creates the parent directory if it doesn't exist, with secure
+      # permissions. The config file is written with mode 0600.
+      #
+      # @param path [String] path to configuration file
+      # @param config [Hash] configuration to save
+      # @return [void]
+      # @raise [Errno::EACCES] if permission denied
+      def save(path, config)
+        dir = File.dirname(path)
+
+        unless File.directory?(dir)
+          FileUtils.mkdir_p(dir)
+          File.chmod(SECURE_DIR_MODE, dir)
+        end
+
+        File.write(path, YAML.dump(config))
+        File.chmod(SECURE_MODE, path)
+      end
+
+      # Updates only the current-context in an existing config file.
+      #
+      # Preserves all other configuration data and file permissions.
+      #
+      # @param path [String] path to configuration file
+      # @param context_name [String] new current context name
+      # @return [void]
+      # @raise [ConfigNotFoundError] if file does not exist
+      def update_current_context(path, context_name)
+        raise ConfigNotFoundError, "Configuration file not found: #{path}" unless File.exist?(path)
+
+        config = YAML.safe_load(File.read(path), permitted_classes: [Symbol])
+        config["current-context"] = context_name
+
+        # Preserve original permissions
+        mode = File.stat(path).mode & 0o777
+        File.write(path, YAML.dump(config))
+        File.chmod(mode, path)
+      end
+
+      # Adds or updates a context in the configuration file.
+      #
+      # If a context with the same name exists, it is replaced.
+      # Otherwise, the new context is appended.
+      #
+      # @param path [String] path to configuration file
+      # @param context [Models::Context] context to add or update
+      # @return [void]
+      # @raise [ConfigNotFoundError] if file does not exist
+      def upsert_context(path, context)
+        raise ConfigNotFoundError, "Configuration file not found: #{path}" unless File.exist?(path)
+
+        config = YAML.safe_load(File.read(path), permitted_classes: [Symbol])
+        contexts = config["contexts"] ||= []
+
+        # Find existing context index
+        existing_index = contexts.find_index { |c| c["name"] == context.name }
+
+        if existing_index
+          contexts[existing_index] = context.to_hash
+        else
+          contexts << context.to_hash
+        end
+
+        # Preserve original permissions
+        mode = File.stat(path).mode & 0o777
+        File.write(path, YAML.dump(config))
+        File.chmod(mode, path)
+      end
+
+      # Adds or updates a cluster in the configuration file.
+      #
+      # If a cluster with the same name exists, it is replaced.
+      # Otherwise, the new cluster is appended.
+      #
+      # @param path [String] path to configuration file
+      # @param cluster [Models::Cluster] cluster to add or update
+      # @return [void]
+      # @raise [ConfigNotFoundError] if file does not exist
+      def upsert_cluster(path, cluster)
+        raise ConfigNotFoundError, "Configuration file not found: #{path}" unless File.exist?(path)
+
+        config = YAML.safe_load(File.read(path), permitted_classes: [Symbol])
+        clusters = config["clusters"] ||= []
+
+        # Find existing cluster index
+        existing_index = clusters.find_index { |c| c["name"] == cluster.name }
+
+        if existing_index
+          clusters[existing_index] = cluster.to_hash
+        else
+          clusters << cluster.to_hash
+        end
+
+        # Preserve original permissions
+        mode = File.stat(path).mode & 0o777
+        File.write(path, YAML.dump(config))
+        File.chmod(mode, path)
+      end
+
+      # Adds or updates a user in the configuration file.
+      #
+      # If a user with the same name exists, it is replaced.
+      # Otherwise, the new user is appended.
+      #
+      # @param path [String] path to configuration file
+      # @param user [Models::User] user to add or update
+      # @return [void]
+      # @raise [ConfigNotFoundError] if file does not exist
+      def upsert_user(path, user)
+        raise ConfigNotFoundError, "Configuration file not found: #{path}" unless File.exist?(path)
+
+        config = YAML.safe_load(File.read(path), permitted_classes: [Symbol])
+        users = config["users"] ||= []
+
+        # Find existing user index
+        existing_index = users.find_index { |u| u["name"] == user.name }
+
+        if existing_index
+          users[existing_index] = user.to_hash
+        else
+          users << user.to_hash
+        end
+
+        # Preserve original permissions
+        mode = File.stat(path).mode & 0o777
+        File.write(path, YAML.dump(config))
+        File.chmod(mode, path)
+      end
+    end
+  end
+end

data/lib/pvectl/config/wizard.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Config
+    # Interactive configuration wizard for first-time setup.
+    #
+    # Wizard guides users through initial configuration by prompting
+    # for server URL, authentication credentials, and SSL settings.
+    # It only runs when stdin is a TTY (not in pipes or scripts).
+    #
+    # @example Checking if wizard is available
+    #   if Wizard.available?
+    #     wizard = Wizard.new
+    #     config = wizard.run
+    #   end
+    #
+    # @example Using custom prompt (for testing)
+    #   wizard = Wizard.new(prompt: mock_prompt)
+    #   config = wizard.run
+    #
+    class Wizard
+      # Checks if the wizard can run (stdin is a TTY).
+      #
+      # @return [Boolean] true if stdin is a TTY
+      def self.available?
+        $stdin.tty?
+      end
+
+      # Creates a new Wizard instance.
+      #
+      # @param prompt [Object, nil] prompt object for user input (default: built-in)
+      def initialize(prompt: nil)
+        @prompt = prompt || create_default_prompt
+      end
+
+      # Runs the interactive wizard and returns configuration.
+      #
+      # @return [Hash] configuration hash ready for YAML serialization
+      def run
+        server = prompt_server
+        verify_ssl = prompt_ssl
+        auth_type = prompt_auth_type
+        credentials = prompt_credentials(auth_type)
+        context_name = prompt_context_name
+
+        build_config(
+          server: server,
+          verify_ssl: verify_ssl,
+          auth_type: auth_type,
+          credentials: credentials,
+          context_name: context_name
+        )
+      end
+
+      private
+
+      attr_reader :prompt
+
+      # Creates a default prompt using TTY::Prompt if available.
+      #
+      # @return [Object] prompt object
+      def create_default_prompt
+        # Try to load TTY::Prompt if available
+        begin
+          require "tty-prompt"
+          TTY::Prompt.new
+        rescue LoadError
+          # Fallback to simple prompt
+          SimplePrompt.new
+        end
+      end
+
+      # Prompts for the Proxmox server URL.
+      #
+      # @return [String] server URL
+      def prompt_server
+        prompt.ask("Proxmox server URL (e.g., https://pve.example.com:8006):")
+      end
+
+      # Prompts for SSL verification preference.
+      #
+      # @return [Boolean] true if SSL should be verified
+      def prompt_ssl
+        prompt.yes?("Verify SSL certificate?")
+      end
+
+      # Prompts for authentication type selection.
+      #
+      # @return [Symbol] :token or :password
+      def prompt_auth_type
+        prompt.select("Authentication method:", [
+          { name: "API Token (recommended)", value: :token },
+          { name: "Username/Password", value: :password }
+        ])
+      end
+
+      # Prompts for authentication credentials.
+      #
+      # @param auth_type [Symbol] :token or :password
+      # @return [Hash] credentials hash
+      def prompt_credentials(auth_type)
+        if auth_type == :token
+          {
+            token_id: prompt.ask("Token ID (e.g., root@pam!tokenid):"),
+            token_secret: prompt.mask("Token Secret:")
+          }
+        else
+          {
+            username: prompt.ask("Username (e.g., root@pam):"),
+            password: prompt.mask("Password:")
+          }
+        end
+      end
+
+      # Prompts for context name.
+      #
+      # @return [String] context name
+      def prompt_context_name
+        prompt.ask("Context name:", default: "default")
+      end
+
+      # Builds the configuration hash from collected data.
+      #
+      # @param server [String] server URL
+      # @param verify_ssl [Boolean] SSL verification
+      # @param auth_type [Symbol] authentication type
+      # @param credentials [Hash] authentication credentials
+      # @param context_name [String] context name
+      # @return [Hash] configuration hash
+      def build_config(server:, verify_ssl:, auth_type:, credentials:, context_name:)
+        cluster_name = context_name
+        user_name = "#{context_name}-user"
+
+        {
+          "apiVersion" => "pvectl/v1",
+          "kind" => "Config",
+          "clusters" => [
+            {
+              "name" => cluster_name,
+              "cluster" => {
+                "server" => server,
+                "insecure-skip-tls-verify" => !verify_ssl
+              }
+            }
+          ],
+          "users" => [
+            build_user_config(user_name, auth_type, credentials)
+          ],
+          "contexts" => [
+            {
+              "name" => context_name,
+              "context" => {
+                "cluster" => cluster_name,
+                "user" => user_name
+              }
+            }
+          ],
+          "current-context" => context_name
+        }
+      end
+
+      # Builds user configuration hash.
+      #
+      # @param name [String] user name
+      # @param auth_type [Symbol] :token or :password
+      # @param credentials [Hash] credentials
+      # @return [Hash] user configuration
+      def build_user_config(name, auth_type, credentials)
+        user_data = if auth_type == :token
+                      {
+                        "token-id" => credentials[:token_id],
+                        "token-secret" => credentials[:token_secret]
+                      }
+                    else
+                      {
+                        "username" => credentials[:username],
+                        "password" => credentials[:password]
+                      }
+                    end
+
+        {
+          "name" => name,
+          "user" => user_data
+        }
+      end
+
+      # Validates server URL format.
+      #
+      # @param url [String] URL to validate
+      # @return [Boolean] true if valid
+      def valid_server_url?(url)
+        return false if url.nil? || url.empty?
+
+        uri = URI.parse(url)
+        uri.scheme == "https" && !uri.host.nil?
+      rescue URI::InvalidURIError
+        false
+      end
+
+      # Validates token ID format.
+      #
+      # @param token_id [String] token ID to validate
+      # @return [Boolean] true if valid (contains @ and !)
+      def valid_token_id?(token_id)
+        return false if token_id.nil? || token_id.empty?
+
+        token_id.include?("@") && token_id.include?("!")
+      end
+    end
+
+    # Simple fallback prompt when TTY::Prompt is not available.
+    #
+    # Provides basic input methods without fancy formatting.
+    #
+    class SimplePrompt
+      # Asks a question and returns the answer.
+      #
+      # @param question [String] question to ask
+      # @param default [Object, nil] default value
+      # @param required [Boolean] whether a non-empty answer is required
+      # @param convert [Symbol, nil] type conversion (+:int+, +:float+, +:bool+)
+      # @return [Object] user input (converted if requested)
+      def ask(question, default: nil, required: false, convert: nil, **)
+        loop do
+          print "#{question} "
+          print "[#{default}] " if default
+          input = $stdin.gets&.chomp
+          value = input.nil? || input.empty? ? default : input
+
+          if required && (value.nil? || value.to_s.empty?)
+            puts "Value is required."
+            next
+          end
+
+          return convert_value(value, convert)
+        end
+      end
+
+      # Asks a yes/no question.
+      #
+      # @param question [String] question to ask
+      # @return [Boolean] true for yes
+      def yes?(question, **)
+        print "#{question} (y/n) "
+        input = $stdin.gets&.chomp&.downcase
+        %w[y yes].include?(input)
+      end
+
+      # Prompts for selection from choices.
+      #
+      # @param question [String] question to ask
+      # @param choices [Array] list of choices
+      # @return [Object] selected value
+      def select(question, choices, **)
+        puts question
+        choices.each_with_index do |choice, index|
+          name = choice.is_a?(Hash) ? choice[:name] : choice
+          puts "  #{index + 1}. #{name}"
+        end
+        print "Enter number: "
+        input = $stdin.gets&.chomp&.to_i || 1
+        choice = choices[input - 1] || choices.first
+        choice.is_a?(Hash) ? choice[:value] : choice
+      end
+
+      # Asks for masked input (password).
+      #
+      # @param question [String] question to ask
+      # @return [String] user input
+      def mask(question, **)
+        print "#{question} "
+        begin
+          $stdin.noecho { $stdin.gets&.chomp }
+        rescue NoMethodError
+          # Fallback if noecho not available
+          $stdin.gets&.chomp
+        ensure
+          puts
+        end
+      end
+
+      def ok(_message); end
+
+      def warn(_message); end
+
+      def error(_message); end
+
+      private
+
+      # Converts a string value to the requested type.
+      #
+      # @param value [Object] raw value
+      # @param type [Symbol, nil] target type (+:int+, +:float+, +:bool+)
+      # @return [Object] converted value
+      def convert_value(value, type)
+        return value if type.nil? || value.nil?
+
+        case type
+        when :int, :integer then value.to_s.empty? ? value : Integer(value)
+        when :float         then value.to_s.empty? ? value : Float(value)
+        when :bool, :boolean
+          %w[y yes true 1].include?(value.to_s.downcase)
+        else
+          value
+        end
+      end
+    end
+  end
+end