pvectl 0.2.0

data/lib/pvectl/commands/cloudinit/regenerate.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Cloudinit
+      # Handler for the `pvectl cloudinit regenerate vm <id>` subcommand.
+      #
+      # Triggers Proxmox to rebuild the cloud-init ISO from the current
+      # VM configuration. The operation is synchronous on the Proxmox side
+      # and returns null on success.
+      #
+      # @example Usage
+      #   pvectl cloudinit regenerate vm 100
+      #   pvectl cloudinit regenerate vm 100 --node pve2
+      #
+      class Regenerate
+        # Registers the regenerate subcommand under the cloudinit parent.
+        #
+        # @param parent [GLI::Command] parent cloudinit command
+        # @return [void]
+        def self.register_subcommand(parent)
+          parent.desc "Regenerate the cloud-init ISO for a VM"
+          parent.long_desc <<~HELP
+            DESCRIPTION
+              Rebuild the cloud-init configuration drive (ISO) for a VM from
+              the current Proxmox configuration. This is required after
+              editing cloud-init-related options (user, ipconfig, sshkeys, etc.)
+              for the changes to take effect inside the guest on next boot.
+
+            EXAMPLES
+              Regenerate cloud-init for VM 100:
+                $ pvectl cloudinit regenerate vm 100
+
+              Skip VMID lookup by passing the node explicitly:
+                $ pvectl cloudinit regenerate vm 100 --node pve2
+
+            NOTES
+              Cloud-init is a VM-only feature — LXC containers do not expose
+              cloud-init endpoints.
+
+              The VM does NOT need to be running. The regenerated ISO will
+              be picked up at the next guest reboot.
+
+            SEE ALSO
+              pvectl help cloudinit pending   Show pending cloud-init changes
+              pvectl help cloudinit dump      Inspect generated cloud-init YAML
+          HELP
+          parent.arg_name "RESOURCE_TYPE ID"
+          parent.command :regenerate do |c|
+            c.action do |global_options, options, args|
+              exit_code = execute(args, options, global_options)
+              exit exit_code if exit_code != 0
+            end
+          end
+        end
+
+        # Executes the regenerate subcommand.
+        #
+        # @param args [Array<String>] command arguments (RESOURCE_TYPE, ID)
+        # @param options [Hash] command-local options (:node)
+        # @param global_options [Hash] global CLI options
+        # @return [Integer] exit code
+        def self.execute(args, options, global_options)
+          resource_type = args[0]
+          vmid_arg = args[1]
+
+          return Cloudinit.usage_error("Resource type required (vm)") unless resource_type
+          return Cloudinit.usage_error("VMID is required") unless vmid_arg
+          return Cloudinit.unknown_resource_type(resource_type) unless resource_type == "vm"
+
+          Cloudinit.with_service(global_options) do |service|
+            result = service.regenerate(vmid_arg.to_i, node: options[:node])
+            $stdout.puts "Cloud-init ISO regenerated for VM #{result[:vmid]} on #{result[:node]}."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/commands/config/command.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Config
+      # Registers the `pvectl config` command group with all subcommands.
+      #
+      # @example
+      #   Commands::Config::Command.register(cli)
+      #
+      class Command
+        # Registers the config command and all subcommands with the CLI.
+        #
+        # @param cli [GLI::App] the CLI application object
+        # @return [void]
+        def self.register(cli)
+          cli.desc "Manage pvectl configuration"
+          cli.long_desc <<~HELP
+            Manage pvectl configuration. Configuration uses kubeconfig-style
+            contexts to support multiple Proxmox clusters.
+
+            Configuration file location: ~/.pvectl/config
+
+            SUBCOMMANDS
+              config get-contexts       List all available contexts
+              config use-context NAME   Switch to a different context
+              config set-context NAME   Create or modify a context
+              config set-cluster NAME   Create or modify a cluster definition
+              config set-credentials NAME  Create or modify user credentials
+              config view               Display current configuration (secrets masked)
+
+            EXAMPLES
+              View current configuration:
+                $ pvectl config view
+
+              Switch to a different context:
+                $ pvectl config use-context production
+
+              Set up a new cluster:
+                $ pvectl config set-cluster prod --server=https://pve.example.com:8006
+                $ pvectl config set-credentials admin --token-id=root@pam!pvectl --token-secret=xxx
+                $ pvectl config set-context prod --cluster=prod --user=admin
+
+            NOTES
+              On first run, pvectl launches an interactive wizard if no config exists.
+
+              Environment variables (PROXMOX_HOST, PROXMOX_TOKEN_ID, etc.) override
+              config file values. Use PVECTL_CONTEXT to override the active context.
+
+            SEE ALSO
+              pvectl help ping          Test connectivity after configuration
+          HELP
+          cli.command :config do |c|
+            UseContext.register_subcommand(c)
+            GetContexts.register_subcommand(c)
+            SetContext.register_subcommand(c)
+            SetCluster.register_subcommand(c)
+            SetCredentials.register_subcommand(c)
+            View.register_subcommand(c)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/commands/config/get_contexts.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Config
+      # Handler for the `pvectl config get-contexts` command.
+      #
+      # Lists all contexts defined in the configuration file with
+      # an indicator showing which context is currently active.
+      # Uses the unified OutputHelper for formatting output.
+      #
+      # @example Usage
+      #   pvectl config get-contexts
+      #   pvectl config get-contexts -o json
+      #   pvectl config get-contexts -o yaml
+      #   pvectl config get-contexts -o wide
+      #   pvectl config get-contexts --no-color
+      #
+      class GetContexts
+        # Registers the get-contexts subcommand.
+        #
+        # @param parent [GLI::Command] parent config command
+        # @return [void]
+        def self.register_subcommand(parent)
+          parent.desc "List all available contexts"
+          parent.long_desc <<~HELP
+            List all contexts defined in the configuration file. The currently
+            active context is marked with an asterisk (*).
+
+            EXAMPLES
+              $ pvectl config get-contexts
+          HELP
+          parent.command :"get-contexts" do |get_ctx|
+            get_ctx.action do |global_options, _options, _args|
+              exit_code = execute(global_options)
+              exit exit_code if exit_code != 0
+            end
+          end
+        end
+
+        # Executes the get-contexts command.
+        #
+        # @param global_options [Hash] global CLI options (includes :config, :output, :color)
+        # @return [Integer] exit code (0 for success)
+        def self.execute(global_options)
+          config_path = global_options[:config]
+
+          service = Pvectl::Config::Service.new
+          service.load(config: config_path)
+
+          contexts = service.contexts
+          current_context_name = service.current_context_name
+          presenter = Pvectl::Presenters::Config::Context.new
+
+          Pvectl::Formatters::OutputHelper.print(
+            data: contexts,
+            presenter: presenter,
+            format: global_options[:output] || "table",
+            color_flag: global_options[:color],
+            current_context: current_context_name
+          )
+
+          0
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/commands/config/set_cluster.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Config
+      # Handler for the `pvectl config set-cluster` command.
+      #
+      # Creates a new cluster or modifies an existing one in the configuration.
+      # Requires --server flag for new clusters.
+      #
+      # @example Usage
+      #   pvectl config set-cluster staging --server=https://pve-staging.example.com:8006
+      #   pvectl config set-cluster prod --server=https://pve.example.com:8006 --certificate-authority=/path/to/ca.crt
+      #   pvectl config set-cluster dev --server=https://pve-dev.local:8006 --insecure-skip-tls-verify
+      #
+      class SetCluster
+        # Registers the set-cluster subcommand.
+        #
+        # @param parent [GLI::Command] parent config command
+        # @return [void]
+        def self.register_subcommand(parent)
+          parent.desc "Create or modify a cluster"
+          parent.long_desc <<~HELP
+            Create a new cluster definition or modify an existing one.
+
+            EXAMPLES
+              Add a cluster:
+                $ pvectl config set-cluster production --server=https://pve.example.com:8006
+
+              Skip TLS verification (testing only):
+                $ pvectl config set-cluster lab --server=https://pve-lab:8006 --insecure-skip-tls-verify
+          HELP
+          parent.command :"set-cluster" do |set_cluster|
+            set_cluster.arg_name "CLUSTER_NAME"
+
+            set_cluster.desc "Proxmox server URL (e.g., https://pve.example.com:8006)"
+            set_cluster.flag [:server]
+
+            set_cluster.desc "Path to CA certificate file"
+            set_cluster.flag [:"certificate-authority"]
+
+            set_cluster.desc "Skip TLS certificate verification"
+            set_cluster.switch [:"insecure-skip-tls-verify"], negatable: false
+
+            set_cluster.action do |global_options, options, args|
+              if args.empty?
+                $stderr.puts "Error: cluster name is required"
+                exit ExitCodes::USAGE_ERROR
+              end
+              exit_code = execute(args[0], options, global_options)
+              exit exit_code if exit_code != 0
+            end
+          end
+        end
+
+        # Executes the set-cluster command.
+        #
+        # @param cluster_name [String] name of the cluster to create or modify
+        # @param options [Hash] command options (:server, :certificate_authority, :insecure_skip_tls_verify)
+        # @param global_options [Hash] global CLI options (includes :config)
+        # @return [Integer] exit code (0 for success)
+        def self.execute(cluster_name, options, global_options)
+          config_path = global_options[:config]
+          service = Pvectl::Config::Service.new
+          service.load(config: config_path)
+
+          existing_cluster = service.cluster(cluster_name)
+          action = existing_cluster ? "modified" : "created"
+
+          # Use existing values if not provided
+          server = options[:server] || existing_cluster&.server
+          certificate_authority = options[:"certificate-authority"] ||
+                                  options[:certificate_authority] ||
+                                  existing_cluster&.certificate_authority
+
+          # Handle insecure-skip-tls-verify flag
+          insecure_skip = options[:"insecure-skip-tls-verify"]
+          verify_ssl = if insecure_skip.nil?
+                         existing_cluster ? existing_cluster.verify_ssl : true
+                       else
+                         !insecure_skip
+                       end
+
+          # Validate required fields for new clusters
+          if server.nil?
+            $stderr.puts "Error: --server is required for new clusters"
+            return ExitCodes::USAGE_ERROR
+          end
+
+          service.set_cluster(
+            name: cluster_name,
+            server: server,
+            verify_ssl: verify_ssl,
+            certificate_authority: certificate_authority
+          )
+
+          puts "Cluster \"#{cluster_name}\" #{action}."
+          0
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/commands/config/set_context.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Config
+      # Handler for the `pvectl config set-context` command.
+      #
+      # Creates a new context or modifies an existing one in the configuration.
+      # Requires --cluster and --user flags for new contexts.
+      #
+      # @example Usage
+      #   pvectl config set-context production --cluster=pve-prod --user=admin
+      #   pvectl config set-context dev --cluster=pve-dev --user=admin --default-node=pve1
+      #
+      class SetContext
+        # Registers the set-context subcommand.
+        #
+        # @param parent [GLI::Command] parent config command
+        # @return [void]
+        def self.register_subcommand(parent)
+          parent.desc "Create or modify a context"
+          parent.long_desc <<~HELP
+            Create a new context or modify an existing one. A context links
+            a cluster definition with user credentials.
+
+            EXAMPLES
+              Create a new context:
+                $ pvectl config set-context prod --cluster=production --user=admin-prod
+
+              Set a default node:
+                $ pvectl config set-context prod --default-node=pve1
+          HELP
+          parent.command :"set-context" do |set_ctx|
+            set_ctx.arg_name "CONTEXT_NAME"
+
+            set_ctx.desc "Cluster name"
+            set_ctx.flag [:cluster]
+
+            set_ctx.desc "User name"
+            set_ctx.flag [:user]
+
+            set_ctx.desc "Default node"
+            set_ctx.flag [:"default-node"]
+
+            set_ctx.action do |global_options, options, args|
+              if args.empty?
+                $stderr.puts "Error: context name is required"
+                exit ExitCodes::USAGE_ERROR
+              end
+              exit_code = execute(args[0], options, global_options)
+              exit exit_code if exit_code != 0
+            end
+          end
+        end
+
+        # Executes the set-context command.
+        #
+        # @param context_name [String] name of the context to create or modify
+        # @param options [Hash] command options (:cluster, :user, :default_node)
+        # @param global_options [Hash] global CLI options (includes :config)
+        # @return [Integer] exit code (0 for success)
+        # @raise [Config::ClusterNotFoundError] if cluster doesn't exist
+        # @raise [Config::UserNotFoundError] if user doesn't exist
+        def self.execute(context_name, options, global_options)
+          config_path = global_options[:config]
+          service = Pvectl::Config::Service.new
+          service.load(config: config_path)
+
+          existing_context = service.context(context_name)
+          action = existing_context ? "modified" : "created"
+
+          # Use existing values if not provided
+          cluster = options[:cluster] || existing_context&.cluster_ref
+          user = options[:user] || existing_context&.user_ref
+          default_node = options[:"default-node"] || options[:default_node] || existing_context&.default_node
+
+          # Validate required fields for new contexts
+          if cluster.nil? || user.nil?
+            $stderr.puts "Error: --cluster and --user are required for new contexts"
+            return ExitCodes::USAGE_ERROR
+          end
+
+          # Validate cluster and user exist
+          validate_cluster_exists!(service, cluster)
+          validate_user_exists!(service, user)
+
+          service.set_context(
+            name: context_name,
+            cluster: cluster,
+            user: user,
+            default_node: default_node
+          )
+
+          puts "Context \"#{context_name}\" #{action}."
+          0
+        rescue Pvectl::Config::ClusterNotFoundError => e
+          $stderr.puts "Error: #{e.message}"
+          ExitCodes::CONFIG_ERROR
+        rescue Pvectl::Config::UserNotFoundError => e
+          $stderr.puts "Error: #{e.message}"
+          ExitCodes::CONFIG_ERROR
+        end
+
+        # Validates that the cluster exists in the configuration.
+        #
+        # @param service [Config::Service] configuration service
+        # @param cluster_name [String] cluster name to validate
+        # @raise [Config::ClusterNotFoundError] if cluster doesn't exist
+        def self.validate_cluster_exists!(service, cluster_name)
+          clusters = service.raw_config["clusters"] || []
+          found = clusters.any? { |c| c["name"] == cluster_name }
+          unless found
+            available = clusters.map { |c| c["name"] }.join(", ")
+            raise Pvectl::Config::ClusterNotFoundError,
+                  "Cluster '#{cluster_name}' not found in configuration. Available: #{available}"
+          end
+        end
+
+        # Validates that the user exists in the configuration.
+        #
+        # @param service [Config::Service] configuration service
+        # @param user_name [String] user name to validate
+        # @raise [Config::UserNotFoundError] if user doesn't exist
+        def self.validate_user_exists!(service, user_name)
+          users = service.raw_config["users"] || []
+          found = users.any? { |u| u["name"] == user_name }
+          unless found
+            available = users.map { |u| u["name"] }.join(", ")
+            raise Pvectl::Config::UserNotFoundError,
+                  "User '#{user_name}' not found in configuration. Available: #{available}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/commands/config/set_credentials.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Config
+      # Handler for the `pvectl config set-credentials` command.
+      #
+      # Creates a new user or modifies existing credentials in the configuration.
+      # Supports two authentication methods:
+      # - API Token: --token-id and --token-secret
+      # - Password: --username and --password
+      #
+      # @example Usage with token authentication
+      #   pvectl config set-credentials admin --token-id=root@pam!automation --token-secret=xxx-xxx
+      #
+      # @example Usage with password authentication
+      #   pvectl config set-credentials dev-user --username=root@pam --password=secret
+      #
+      class SetCredentials
+        # Registers the set-credentials subcommand.
+        #
+        # @param parent [GLI::Command] parent config command
+        # @return [void]
+        def self.register_subcommand(parent)
+          parent.desc "Create or modify user credentials"
+          parent.long_desc <<~HELP
+            Create or modify user credentials. Supports API token (recommended)
+            and username/password authentication.
+
+            EXAMPLES
+              Set API token credentials:
+                $ pvectl config set-credentials admin --token-id=root@pam!pvectl --token-secret=xxx
+
+              Set username/password credentials:
+                $ pvectl config set-credentials admin --username=root@pam --password=secret
+
+            NOTES
+              API tokens are recommended over passwords — they are more secure
+              and don't expire with password changes.
+          HELP
+          parent.command :"set-credentials" do |set_creds|
+            set_creds.arg_name "USER_NAME"
+
+            set_creds.desc "API token ID (e.g., root@pam!tokenname)"
+            set_creds.flag [:"token-id"]
+
+            set_creds.desc "API token secret"
+            set_creds.flag [:"token-secret"]
+
+            set_creds.desc "Username for password authentication"
+            set_creds.flag [:username]
+
+            set_creds.desc "Password for password authentication"
+            set_creds.flag [:password]
+
+            set_creds.action do |global_options, options, args|
+              if args.empty?
+                $stderr.puts "Error: user name is required"
+                exit ExitCodes::USAGE_ERROR
+              end
+              exit_code = execute(args[0], options, global_options)
+              exit exit_code if exit_code != 0
+            end
+          end
+        end
+
+        # Executes the set-credentials command.
+        #
+        # @param user_name [String] name of the user to create or modify
+        # @param options [Hash] command options (:token_id, :token_secret, :username, :password)
+        # @param global_options [Hash] global CLI options (includes :config)
+        # @return [Integer] exit code (0 for success)
+        def self.execute(user_name, options, global_options)
+          config_path = global_options[:config]
+          service = Pvectl::Config::Service.new
+          service.load(config: config_path)
+
+          existing_user = service.user(user_name)
+          action = existing_user ? "modified" : "created"
+
+          # Use existing values if not provided
+          token_id = options[:"token-id"] || options[:token_id] || existing_user&.token_id
+          token_secret = options[:"token-secret"] || options[:token_secret] || existing_user&.token_secret
+          username = options[:username] || existing_user&.username
+          password = options[:password] || existing_user&.password
+
+          # Validate credentials for new users
+          if existing_user.nil?
+            validation_error = validate_new_user_credentials(token_id, token_secret, username, password)
+            return validation_error if validation_error
+          else
+            # For existing users, validate that partial updates are complete
+            validation_error = validate_partial_update(options, existing_user)
+            return validation_error if validation_error
+          end
+
+          service.set_credentials(
+            name: user_name,
+            token_id: token_id,
+            token_secret: token_secret,
+            username: username,
+            password: password
+          )
+
+          puts "User \"#{user_name}\" #{action}."
+          0
+        end
+
+        # Validates credentials for a new user.
+        #
+        # @param token_id [String, nil] API token ID
+        # @param token_secret [String, nil] API token secret
+        # @param username [String, nil] username
+        # @param password [String, nil] password
+        # @return [Integer, nil] exit code if validation fails, nil otherwise
+        def self.validate_new_user_credentials(token_id, token_secret, username, password)
+          has_token_auth = token_id && token_secret
+          has_password_auth = username && password
+
+          if !has_token_auth && !has_password_auth
+            if token_id && !token_secret
+              $stderr.puts "Error: --token-secret is required when using --token-id"
+              return ExitCodes::USAGE_ERROR
+            elsif token_secret && !token_id
+              $stderr.puts "Error: --token-id is required when using --token-secret"
+              return ExitCodes::USAGE_ERROR
+            elsif username && !password
+              $stderr.puts "Error: --password is required when using --username"
+              return ExitCodes::USAGE_ERROR
+            elsif password && !username
+              $stderr.puts "Error: --username is required when using --password"
+              return ExitCodes::USAGE_ERROR
+            else
+              $stderr.puts "Error: credentials required (--token-id/--token-secret or --username/--password)"
+              return ExitCodes::USAGE_ERROR
+            end
+          end
+
+          nil
+        end
+
+        # Validates partial update for existing user.
+        #
+        # @param options [Hash] command options
+        # @param existing_user [Models::User] existing user model
+        # @return [Integer, nil] exit code if validation fails, nil otherwise
+        def self.validate_partial_update(options, existing_user)
+          # Check if user is trying to set incomplete token auth
+          token_id_provided = options[:"token-id"] || options[:token_id]
+          token_secret_provided = options[:"token-secret"] || options[:token_secret]
+
+          if token_id_provided && !token_secret_provided && existing_user.token_secret.nil?
+            $stderr.puts "Error: --token-secret is required when using --token-id"
+            return ExitCodes::USAGE_ERROR
+          end
+
+          if token_secret_provided && !token_id_provided && existing_user.token_id.nil?
+            $stderr.puts "Error: --token-id is required when using --token-secret"
+            return ExitCodes::USAGE_ERROR
+          end
+
+          # Check if user is trying to set incomplete password auth
+          username_provided = options[:username]
+          password_provided = options[:password]
+
+          if username_provided && !password_provided && existing_user.password.nil?
+            $stderr.puts "Error: --password is required when using --username"
+            return ExitCodes::USAGE_ERROR
+          end
+
+          if password_provided && !username_provided && existing_user.username.nil?
+            $stderr.puts "Error: --username is required when using --password"
+            return ExitCodes::USAGE_ERROR
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end