makit 0.0.99 → 0.0.112

data/lib/makit/commands/middleware/validator.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "uri"
+
+module Makit
+  module Commands
+    # Custom exception for security-related command validation failures
+    class SecurityError < StandardError; end
+
+    module Middleware
+      # Validation middleware that provides input sanitization and security checks
+      # for command execution contexts.
+      #
+      # This middleware validates and sanitizes:
+      # - Command strings for shell injection attacks
+      # - File paths for directory traversal
+      # - URLs for malicious schemes
+      # - Environment variables for sensitive data
+      # - Arguments for dangerous patterns
+      #
+      # @example Basic usage
+      #   validator = Commands::Middleware::Validator.new
+      #   context = Commands::Context.new(command: 'ls -la')
+      #   validated_context = validator.call(context)
+      #
+      # @example With custom validation rules
+      #   validator = Commands::Middleware::Validator.new(
+      #     allow_shell_operators: false,
+      #     blocked_commands: %w[rm sudo],
+      #     max_command_length: 500
+      #   )
+      class Validator
+        # Default blocked commands that pose security risks
+        DEFAULT_BLOCKED_COMMANDS = %w[
+          rm rmdir
+          sudo su
+          chmod chown
+          wget curl
+          eval exec
+          python ruby node
+          ssh scp rsync
+          dd fdisk mount umount
+          iptables ufw
+          systemctl service
+          crontab
+          passwd
+        ].freeze
+
+        # Dangerous shell operators and patterns
+        DANGEROUS_PATTERNS = [
+          /[;&|`$(){}]/, # Shell operators and command substitution
+          %r{\.\./}, # Directory traversal
+          %r{/etc/|/proc/|/sys/}, # Sensitive system directories
+          /\$\{[^}]*\}/, # Variable expansion
+          %r{~[^/\s]*}, # User home directory expansion
+          %r{\bfile://|ftp://|https?://[^\s]*\.(sh|py|rb|js|exe|bat)\b}i, # Executable URLs
+        ].freeze
+
+        # Maximum allowed lengths for various inputs
+        DEFAULT_LIMITS = {
+          command_length: 1000,
+          argument_length: 500,
+          path_length: 1000,
+          env_var_value_length: 2000,
+        }.freeze
+
+        attr_reader :options
+
+        # Initialize the validator with security options
+        #
+        # @param options [Hash] Configuration options
+        # @option options [Boolean] :allow_shell_operators (false) Allow shell operators like ;, |, &
+        # @option options [Array<String>] :blocked_commands Commands to block
+        # @option options [Hash] :limits Length limits for various inputs
+        # @option options [Boolean] :strict_mode (true) Enable strict validation
+        # @option options [Array<String>] :allowed_schemes URL schemes to allow
+        def initialize(options = {})
+          @options = {
+            allow_shell_operators: false,
+            blocked_commands: DEFAULT_BLOCKED_COMMANDS,
+            limits: DEFAULT_LIMITS,
+            strict_mode: true,
+            allowed_schemes: %w[http https file],
+            allow_environment_access: false,
+          }.merge(options)
+        end
+
+        # Validate and sanitize the command context
+        #
+        # @param context [Commands::Context] The command execution context
+        # @return [Commands::Context] Validated context
+        # @raise [Commands::SecurityError] If validation fails
+        def call(context)
+          validate_command!(context.command) if context.command
+          validate_arguments!(context.arguments) if context.arguments
+          validate_environment!(context.environment) if context.environment
+          validate_working_directory!(context.working_directory) if context.working_directory
+
+          context
+        rescue StandardError => e
+          raise Commands::SecurityError, "Validation failed: #{e.message}"
+        end
+
+        private
+
+        # Validate the main command string
+        def validate_command!(command)
+          raise Commands::SecurityError, "Empty command" if command.nil? || command.strip.empty?
+
+          if command.length > limits[:command_length]
+            raise Commands::SecurityError,
+                  "Command too long (#{command.length} > #{limits[:command_length]})"
+          end
+
+          # Check for blocked commands
+          command_parts = Shellwords.split(command)
+          base_command = File.basename(command_parts.first || "")
+
+          raise Commands::SecurityError, "Blocked command: #{base_command}" if blocked_commands.include?(base_command)
+
+          # Check for dangerous patterns
+          unless options[:allow_shell_operators]
+            DANGEROUS_PATTERNS.each do |pattern|
+              if command.match?(pattern)
+                raise Commands::SecurityError, "Dangerous pattern detected in command: #{pattern.inspect}"
+              end
+            end
+          end
+
+          # Validate shell escaping
+          begin
+            Shellwords.split(command)
+          rescue ArgumentError => e
+            raise Commands::SecurityError, "Invalid shell command syntax: #{e.message}"
+          end
+        end
+
+        # Validate command arguments
+        def validate_arguments!(arguments)
+          return unless arguments
+
+          arguments.each_with_index do |arg, index|
+            next unless arg
+
+            if arg.length > limits[:argument_length]
+              raise Commands::SecurityError, "Argument #{index} too long (#{arg.length} > #{limits[:argument_length]})"
+            end
+
+            # Check for dangerous patterns in arguments
+            if options[:strict_mode]
+              DANGEROUS_PATTERNS.each do |pattern|
+                if arg.match?(pattern)
+                  raise Commands::SecurityError, "Dangerous pattern in argument #{index}: #{pattern.inspect}"
+                end
+              end
+            end
+
+            # Validate file paths in arguments
+            validate_path!(arg) if looks_like_path?(arg)
+
+            # Validate URLs in arguments
+            validate_url!(arg) if looks_like_url?(arg)
+          end
+        end
+
+        # Validate environment variables
+        def validate_environment!(environment)
+          return unless environment
+
+          environment.each do |key, value|
+            next unless value
+
+            if value.to_s.length > limits[:env_var_value_length]
+              raise Commands::SecurityError, "Environment variable #{key} value too long"
+            end
+
+            # Check for sensitive environment variables
+            if sensitive_env_var?(key) && !options[:allow_environment_access]
+              raise Commands::SecurityError, "Access to sensitive environment variable #{key} not allowed"
+            end
+
+            # Validate environment variable values
+            if options[:strict_mode] && contains_dangerous_content?(value.to_s)
+              raise Commands::SecurityError, "Dangerous content in environment variable #{key}"
+            end
+          end
+        end
+
+        # Validate working directory path
+        def validate_working_directory!(path)
+          validate_path!(path, "working directory")
+        end
+
+        # Validate file system paths
+        def validate_path!(path, context = "path")
+          return if path.nil? || path.empty?
+
+          if path.length > limits[:path_length]
+            raise Commands::SecurityError, "#{context.capitalize} too long (#{path.length} > #{limits[:path_length]})"
+          end
+
+          # Check for directory traversal
+          normalized_path = File.expand_path(path)
+          if path.include?("..") && options[:strict_mode]
+            raise Commands::SecurityError, "Directory traversal detected in #{context}: #{path}"
+          end
+
+          # Check for access to sensitive directories
+          sensitive_dirs = %w[/etc /proc /sys /dev /boot /root]
+          return unless sensitive_dirs.any? { |dir| normalized_path.start_with?(dir) } && options[:strict_mode]
+
+          raise Commands::SecurityError, "Access to sensitive directory in #{context}: #{path}"
+        end
+
+        # Validate URLs
+        def validate_url!(url)
+          uri = URI.parse(url)
+
+          unless options[:allowed_schemes].include?(uri.scheme)
+            raise Commands::SecurityError, "Disallowed URL scheme: #{uri.scheme}"
+          end
+
+          # Check for suspicious hosts
+          if uri.host&.match?(/localhost|127\.0\.0\.1|0\.0\.0\.0/)
+            raise Commands::SecurityError, "Local network access not allowed: #{uri.host}"
+          end
+        rescue URI::InvalidURIError => e
+          raise Commands::SecurityError, "Invalid URL format: #{e.message}"
+        end
+
+        # Check if string looks like a file path
+        def looks_like_path?(str)
+          str.start_with?("/") || str.start_with?("./") || str.start_with?("../") || str.include?(File::SEPARATOR)
+        end
+
+        # Check if string looks like a URL
+        def looks_like_url?(str)
+          str.match?(/\A[a-z][a-z0-9+.-]*:/i)
+        end
+
+        # Check if environment variable is sensitive
+        def sensitive_env_var?(key)
+          sensitive_patterns = %w[
+            PASSWORD SECRET TOKEN KEY API PRIVATE
+            AWS GCP AZURE GITHUB GITLAB
+            DATABASE_URL DB_PASSWORD
+            RAILS_MASTER_KEY
+          ]
+
+          sensitive_patterns.any? { |pattern| key.to_s.upcase.include?(pattern) }
+        end
+
+        # Check if content contains dangerous patterns
+        def contains_dangerous_content?(content)
+          DANGEROUS_PATTERNS.any? { |pattern| content.match?(pattern) }
+        end
+
+        def limits
+          options[:limits]
+        end
+
+        def blocked_commands
+          options[:blocked_commands]
+        end
+      end
+    end
+  end
+end

data/lib/makit/commands/request.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "json"
+
+module Makit
+  module Commands
+    # Enhanced request handling with validation and type safety.
+    # Uses plain Ruby objects - no protobuf dependency for better performance.
+    #
+    # @example Create a simple request
+    #   request = Request.new(command: "git", arguments: ["--version"])
+    #
+    # @example Create request from string
+    #   request = Request.from_string("git clone https://github.com/user/repo.git")
+    #
+    # @example Create request with full options
+    #   request = Request.new(
+    #     command: "bundle",
+    #     arguments: ["install"],
+    #     directory: "/path/to/project",
+    #     environment: { "BUNDLE_JOBS" => "4" },
+    #     timeout: 300,
+    #     metadata: { operation: "dependency_install" }
+    #   )
+    class Request
+      # Command execution request with validation and metadata.
+      #
+      # @!attribute [r] command
+      #   @return [String] the command to execute
+      # @!attribute [r] arguments
+      #   @return [Array<String>] command line arguments
+      # @!attribute [r] environment
+      #   @return [Hash<String,String>] environment variables
+      # @!attribute [r] directory
+      #   @return [String] working directory for execution
+      # @!attribute [r] timeout
+      #   @return [Integer] timeout in seconds
+      # @!attribute [r] metadata
+      #   @return [Hash] additional metadata for logging/tracking
+      attr_reader :command, :arguments, :environment, :directory, :timeout, :metadata
+
+      # Initialize a new command request.
+      #
+      # @param command [String] the command to execute
+      # @param arguments [Array<String>] command arguments
+      # @param environment [Hash<String,String>] environment variables
+      # @param directory [String] working directory
+      # @param timeout [Integer] timeout in seconds
+      # @param metadata [Hash] additional metadata
+      # @raise [ArgumentError] if command is invalid
+      def initialize(command:, arguments: [], **options)
+        @command = validate_command(command)
+        @arguments = validate_arguments(arguments)
+        @environment = options[:environment] || {}
+        @directory = options[:directory] || Dir.pwd
+        @timeout = options[:timeout] || 30
+        @metadata = options[:metadata] || {}
+
+        validate_directory(@directory)
+        validate_timeout(@timeout)
+      end
+
+      # Convert request to shell-executable command string.
+      #
+      # @return [String] shell command string
+      def to_shell_command
+        cmd_parts = [command] + arguments
+        Shellwords.join(cmd_parts)
+      end
+
+      # Convert request to hash representation.
+      #
+      # @return [Hash] hash representation of the request
+      def to_h
+        {
+          command: command,
+          arguments: arguments,
+          environment: environment,
+          directory: directory,
+          timeout: timeout,
+          metadata: metadata,
+        }
+      end
+
+      # Convert request to JSON representation.
+      #
+      # @param args [Array] arguments passed to JSON.generate
+      # @return [String] JSON representation
+      def to_json(*args)
+        JSON.generate(to_h, *args)
+      end
+
+      # Create a request from a shell command string.
+      #
+      # @param command_string [String] shell command string to parse
+      # @param options [Hash] additional options
+      # @return [Request] new request object
+      # @raise [ArgumentError] if command string is invalid
+      # @example
+      #   Request.from_string("git clone https://github.com/user/repo.git")
+      #   Request.from_string("bundle install --jobs 4")
+      def self.from_string(command_string, **options)
+        raise ArgumentError, "Command string cannot be empty" if command_string.nil? || command_string.strip.empty?
+
+        # Parse shell command string into command and arguments
+        parts = Shellwords.split(command_string.strip)
+        command = parts.shift
+        arguments = parts
+
+        new(command: command, arguments: arguments, **options)
+      end
+
+      # Create a request from hash representation.
+      #
+      # @param command_hash [Hash] hash containing command information
+      # @return [Request] new request object
+      # @raise [ArgumentError] if hash is invalid
+      # @example
+      #   Request.from_hash({
+      #     "command" => "git",
+      #     "arguments" => ["clone", "https://github.com/user/repo.git"],
+      #     "timeout" => 300
+      #   })
+      def self.from_hash(command_hash)
+        raise ArgumentError, "Command hash cannot be nil" if command_hash.nil?
+
+        # Convert string keys to symbols for consistency
+        hash = command_hash.is_a?(Hash) ? normalize_hash_keys(command_hash) : command_hash
+
+        new(
+          command: hash[:command] || hash["command"],
+          arguments: hash[:arguments] || hash["arguments"] || [],
+          environment: hash[:environment] || hash["environment"] || {},
+          directory: hash[:directory] || hash["directory"],
+          timeout: hash[:timeout] || hash["timeout"],
+          metadata: hash[:metadata] || hash["metadata"] || {},
+        )
+      end
+
+      # Create a request from JSON string.
+      #
+      # @param json_string [String] JSON string representation
+      # @return [Request] new request object
+      # @raise [JSON::ParserError, ArgumentError] if JSON is invalid
+      def self.from_json(json_string)
+        hash = JSON.parse(json_string)
+        from_hash(hash)
+      end
+
+      # Check if this request represents the same command.
+      #
+      # @param other [Request] another request to compare
+      # @return [Boolean] true if commands are equivalent
+      def equivalent_to?(other)
+        return false unless other.is_a?(Request)
+
+        command == other.command &&
+          arguments == other.arguments &&
+          environment == other.environment &&
+          directory == other.directory
+      end
+
+      # Generate a cache key for this request.
+      #
+      # @return [String] cache key based on command, arguments, and context
+      def cache_key
+        require "digest"
+        content = "#{command}:#{arguments.join(":")}:#{directory}"
+        Digest::SHA256.hexdigest(content)[0..16]
+      end
+
+      private
+
+      # Validate command parameter.
+      #
+      # @param command [String] command to validate
+      # @return [String] validated command
+      # @raise [ArgumentError] if command is invalid
+      def validate_command(command)
+        raise ArgumentError, "Command cannot be nil" if command.nil?
+        raise ArgumentError, "Command cannot be empty" if command.strip.empty?
+
+        cmd = command.strip
+
+        # Check for dangerous characters that could indicate command injection
+        raise ArgumentError, "Command contains potentially dangerous characters" if cmd.match?(/[;&|`$(){}]/)
+
+        cmd
+      end
+
+      # Validate arguments array.
+      #
+      # @param arguments [Array] arguments to validate
+      # @return [Array<String>] validated arguments
+      # @raise [ArgumentError] if arguments are invalid
+      def validate_arguments(arguments)
+        return [] if arguments.nil?
+        raise ArgumentError, "Arguments must be an array" unless arguments.is_a?(Array)
+
+        # Convert all arguments to strings and validate
+        arguments.map do |arg|
+          raise ArgumentError, "Argument cannot be nil" if arg.nil?
+
+          arg.to_s
+        end
+      end
+
+      # Validate directory parameter.
+      #
+      # @param directory [String] directory to validate
+      # @raise [ArgumentError] if directory is invalid
+      def validate_directory(directory)
+        return unless directory
+
+        raise ArgumentError, "Directory must be a string" unless directory.is_a?(String)
+
+        # NOTE: We don't validate directory existence here as it might be created later
+        # We just validate it's a reasonable path format
+        return unless directory.include?("\0")
+
+        raise ArgumentError, "Directory path contains null bytes"
+      end
+
+      # Validate timeout parameter.
+      #
+      # @param timeout [Integer] timeout to validate
+      # @raise [ArgumentError] if timeout is invalid
+      def validate_timeout(timeout)
+        raise ArgumentError, "Timeout must be a positive integer" unless timeout.is_a?(Integer) && timeout.positive?
+
+        return unless timeout > 3600 # 1 hour max
+
+        raise ArgumentError, "Timeout cannot exceed 3600 seconds"
+      end
+
+      # Normalize hash keys to support both string and symbol keys.
+      #
+      # @param hash [Hash] hash to normalize
+      # @return [Hash] hash with normalized keys
+      def self.normalize_hash_keys(hash)
+        normalized = {}
+        hash.each do |key, value|
+          normalized_key = key.is_a?(String) ? key.to_sym : key
+          normalized[key] = value # Keep original key
+          normalized[normalized_key] = value # Add symbol version
+        end
+        normalized
+      end
+
+      private_class_method :normalize_hash_keys
+    end
+  end
+end