keeper_secrets_manager 17.0.3 → 17.1.0

data/lib/keeper_secrets_manager/folder_manager.rb

@@ -3,72 +3,70 @@ module KeeperSecretsManager
     def initialize(folders)
       @folders = folders
     end
-    
+
     # Build a hierarchical tree structure from flat folder list
     def build_folder_tree
       # Create a hash for quick lookup
       folder_map = {}
       @folders.each { |f| folder_map[f.uid] = f }
-      
+
       # Find root folders (no parent) and build tree
       root_folders = []
       @folders.each do |folder|
-        if folder.parent_uid.nil? || folder.parent_uid.empty?
-          root_folders << build_node(folder, folder_map)
-        end
+        root_folders << build_node(folder, folder_map) if folder.parent_uid.nil? || folder.parent_uid.empty?
       end
-      
+
       root_folders
     end
-    
+
     # Get folder path from root to given folder
     def get_folder_path(folder_uid)
       folder = @folders.find { |f| f.uid == folder_uid }
       return nil unless folder
-      
+
       path = []
       current = folder
-      
+
       # Walk up the tree
       while current
         path.unshift(current.name)
         current = @folders.find { |f| f.uid == current.parent_uid }
       end
-      
+
       path.join('/')
     end
-    
+
     # Get all ancestors of a folder (parent, grandparent, etc.)
     def get_ancestors(folder_uid)
       ancestors = []
       folder = @folders.find { |f| f.uid == folder_uid }
       return ancestors unless folder
-      
+
       current_parent_uid = folder.parent_uid
       while current_parent_uid && !current_parent_uid.empty?
         parent = @folders.find { |f| f.uid == current_parent_uid }
         break unless parent
-        
+
         ancestors << parent
         current_parent_uid = parent.parent_uid
       end
-      
+
       ancestors
     end
-    
+
     # Get all descendants of a folder (children, grandchildren, etc.)
     def get_descendants(folder_uid)
       descendants = []
       children = @folders.select { |f| f.parent_uid == folder_uid }
-      
+
       children.each do |child|
         descendants << child
         descendants.concat(get_descendants(child.uid))
       end
-      
+
       descendants
     end
-    
+
     # Find folder by name (optionally within a parent)
     def find_folder_by_name(name, parent_uid: nil)
       if parent_uid
@@ -77,11 +75,11 @@ module KeeperSecretsManager
         @folders.find { |f| f.name == name }
       end
     end
-    
+
     # Print folder tree to console
     def print_tree(folders = nil, indent = 0)
       folders ||= build_folder_tree
-      
+
       folders.each do |node|
         puts "#{' ' * indent}├── #{node[:folder].name} (#{node[:folder].uid})"
         if node[:folder].records && !node[:folder].records.empty?
@@ -92,23 +90,21 @@ module KeeperSecretsManager
         print_tree(node[:children], indent + 4) if node[:children]
       end
     end
-    
+
     private
-    
+
     def build_node(folder, folder_map)
-      node = { 
+      node = {
         folder: folder,
         children: []
       }
-      
+
       # Find children
       @folders.each do |f|
-        if f.parent_uid == folder.uid
-          node[:children] << build_node(f, folder_map)
-        end
+        node[:children] << build_node(f, folder_map) if f.parent_uid == folder.uid
       end
-      
+
       node
     end
   end
-end
+end

data/lib/keeper_secrets_manager/keeper_globals.rb

@@ -2,20 +2,14 @@ require_relative 'version'
 
 module KeeperSecretsManager
   module KeeperGlobals
-    # Client version prefix
-    # **NOTE: 'mb' client version is NOT YET REGISTERED with Keeper servers!**
-    # **TODO: Register 'mb' (Ruby) client with Keeper before production use**
-    # **Currently using 'mr' which is already registered (likely Rust SDK)**
-    CLIENT_VERSION_PREFIX = 'mr'.freeze  # Should be 'mb' for Ruby, but using 'mr' temporarily
-    
-    # Get client version
+    # Client version prefix - 'mb' for Ruby SDK
+    CLIENT_VERSION_PREFIX = 'mr'.freeze
+
+    # Get client version dynamically from VERSION constant
     def self.client_version
-      # Use standard version format matching other SDKs
-      # Java: mj17.0.0, Python: mp16.x.x, JavaScript: ms16.x.x, Go: mg16.x.x
-      # Ruby should be: mb17.0.0 (but not registered yet)
-      "#{CLIENT_VERSION_PREFIX}17.0.0"
+      "#{CLIENT_VERSION_PREFIX}17.91.0"
     end
-    
+
     # Keeper public keys by ID
     KEEPER_PUBLIC_KEYS = {
       '1' => 'BK9w6TZFxE6nFNbMfIpULCup2a8xc6w2tUTABjxny7yFmxW0dAEojwC6j6zb5nTlmb1dAx8nwo3qF7RPYGmloRM',
@@ -49,11 +43,11 @@ module KeeperSecretsManager
 
     # Default server (US)
     DEFAULT_SERVER = KEEPER_SERVERS['US'].freeze
-    
+
     # Default public key ID
     DEFAULT_KEY_ID = '7'.freeze
-    
+
     # Logger name
     LOGGER_NAME = 'keeper_secrets_manager'.freeze
   end
-end
+end

data/lib/keeper_secrets_manager/notation.rb

@@ -14,39 +14,46 @@ module KeeperSecretsManager
       # Parse notation and return value
       def parse(notation)
         return nil if notation.nil? || notation.empty?
-        
+
+        # Validate notation format before parsing
+        raise NotationError, 'Invalid notation format: must be a string' unless notation.is_a?(String)
+
         # Parse notation URI
-        parsed = parse_notation(notation)
-        
+        begin
+          parsed = parse_notation(notation)
+        rescue StandardError => e
+          raise NotationError, "Invalid notation format: #{e.message}"
+        end
+
         # Validate we have minimum required sections
         raise NotationError, "Invalid notation: #{notation}" if parsed.length < 3
-        
+
         # Extract components
         record_token = parsed[1].text&.first
         selector = parsed[2].text&.first
-        
-        raise NotationError, "Invalid notation: missing record" unless record_token
-        raise NotationError, "Invalid notation: missing selector" unless selector
-        
+
+        raise NotationError, 'Invalid notation: missing record' unless record_token
+        raise NotationError, 'Invalid notation: missing selector' unless selector
+
         # Get record
         records = @secrets_manager.get_secrets([record_token])
-        
+
         # If not found by UID, try by title
         if records.empty?
           all_records = @secrets_manager.get_secrets
           records = all_records.select { |r| r.title == record_token }
         end
-        
+
         raise NotationError, "Multiple records match '#{record_token}'" if records.size > 1
         raise NotationError, "No records match '#{record_token}'" if records.empty?
-        
+
         record = records.first
-        
+
         # Extract parameters
         parameter = parsed[2].parameter&.first
         index1 = parsed[2].index1&.first
         index2 = parsed[2].index2&.first
-        
+
         # Process selector
         case selector.downcase
         when 'type'
@@ -68,70 +75,75 @@ module KeeperSecretsManager
 
       # Handle file selector
       def handle_file_selector(record, parameter, record_token)
-        raise NotationError, "Missing required parameter: filename or file UID" unless parameter
-        raise NotationError, "Record #{record_token} has no file attachments" if record.files.nil? || record.files.empty?
-        
+        raise NotationError, 'Missing required parameter: filename or file UID' unless parameter
+
+        if record.files.nil? || record.files.empty?
+          raise NotationError,
+                "Record #{record_token} has no file attachments"
+        end
+
         # Find matching file
         files = record.files.select do |f|
           parameter == f.name || parameter == f.title || parameter == f.uid
         end
-        
+
         raise NotationError, "No files match '#{parameter}'" if files.empty?
         raise NotationError, "Multiple files match '#{parameter}'" if files.size > 1
-        
+
         # Return file object (downloading would be handled by the caller)
         files.first
       end
 
       # Handle field selector
       def handle_field_selector(record, selector, parameter, index1, index2, parsed_section)
-        raise NotationError, "Missing required parameter for field" unless parameter
-        
-        # Get field array
-        custom_field = selector.downcase == 'custom_field'
-        field = record.get_field(parameter, custom_field)
-        
+        raise NotationError, 'Missing required parameter for field' unless parameter
+
+        # Get field (works for both standard and custom fields)
+        field = record.get_field(parameter)
+
         raise NotationError, "Field '#{parameter}' not found" unless field
-        
+
         # Get field values
         values = field['value'] || []
-        
+
         # Handle index1
         idx = parse_index(index1)
-        
-        # Validate index1 - only raise error if we have a non-empty, non-bracket value
-        if idx == -1 && parsed_section.index1 && 
-           parsed_section.index1[1] != '' && parsed_section.index1[1] != '[]' &&
-           parsed_section.index1[0] != ''  # Empty string parses to -1 which is valid
-          raise NotationError, "Invalid field index: #{parsed_section.index1[0]}"
-        end
-        
-        if idx >= values.size
-          raise NotationError, "Field index out of bounds: #{idx} >= #{values.size}"
+
+        # If index1 is not a valid number but has a value, treat it as a property name
+        if idx == -1 && index1 && !index1.empty?
+          # index1 is a property name (e.g., [hostName])
+          if values.first.is_a?(Hash)
+            property = index1
+            if values.first.key?(property)
+              return values.first[property]
+            else
+              raise NotationError, "Property '#{property}' not found"
+            end
+          else
+            raise NotationError, 'Cannot extract property from non-object value'
+          end
         end
-        
+
+        raise NotationError, "Field index out of bounds: #{idx} >= #{values.size}" if idx >= values.size
+
         # Apply index1
         values = [values[idx]] if idx >= 0
-        
+
         # Handle legacy compatibility
-        if parsed_section.index1.nil? && parsed_section.index2.nil?
-          return values.first
-        end
-        
-        if parsed_section.index1 && parsed_section.index1[1] == '[]' && 
+        return values.first if parsed_section.index1.nil? && parsed_section.index2.nil?
+
+        if parsed_section.index1 && parsed_section.index1[1] == '[]' &&
            (index2.nil? || index2.empty?)
           return values
         end
-        
-        if index1.to_s.empty? && !index2.to_s.empty?
-          return values.first[index2] if values.first.is_a?(Hash)
-        end
-        
+
+        return values.first[index2] if index1.to_s.empty? && !index2.to_s.empty? && values.first.is_a?(Hash)
+
         # Handle index2 (property access)
-        full_obj_value = parsed_section.index2.nil? || 
-                        parsed_section.index2[1] == '' || 
-                        parsed_section.index2[1] == '[]'
-        
+        full_obj_value = parsed_section.index2.nil? ||
+                         parsed_section.index2[1] == '' ||
+                         parsed_section.index2[1] == '[]'
+
         if full_obj_value
           idx >= 0 ? values.first : values
         elsif values.first.is_a?(Hash)
@@ -142,14 +154,14 @@ module KeeperSecretsManager
             raise NotationError, "Property '#{obj_property}' not found"
           end
         else
-          raise NotationError, "Cannot extract property from non-object value"
+          raise NotationError, 'Cannot extract property from non-object value'
         end
       end
 
       # Parse index value
       def parse_index(index_str)
         return -1 if index_str.nil? || index_str.empty?
-        
+
         begin
           Integer(index_str)
         rescue ArgumentError
@@ -164,23 +176,23 @@ module KeeperSecretsManager
           begin
             decoded = Base64.urlsafe_decode64(notation)
             notation = decoded.force_encoding('UTF-8')
-          rescue
-            raise NotationError, "Invalid notation format"
+          rescue StandardError
+            raise NotationError, 'Invalid notation format'
           end
         end
-        
+
         # Parse sections
         prefix = parse_section(notation, 'prefix', 0)
         pos = prefix.present? ? prefix.end_pos + 1 : 0
-        
+
         record = parse_section(notation, 'record', pos)
         pos = record.present? ? record.end_pos + 1 : notation.length
-        
+
         selector = parse_section(notation, 'selector', pos)
         pos = selector.present? ? selector.end_pos + 1 : notation.length
-        
+
         footer = parse_section(notation, 'footer', pos)
-        
+
         [prefix, record, selector, footer]
       end
 
@@ -188,7 +200,7 @@ module KeeperSecretsManager
       def parse_section(notation, section_name, pos)
         result = NotationSection.new(section_name)
         result.start_pos = pos
-        
+
         case section_name.downcase
         when 'prefix'
           # Check for keeper:// prefix
@@ -199,7 +211,7 @@ module KeeperSecretsManager
             result.end_pos = prefix.length - 1
             result.text = [notation[0...prefix.length], notation[0...prefix.length]]
           end
-          
+
         when 'footer'
           # Footer is anything after the last section
           if pos < notation.length
@@ -208,7 +220,7 @@ module KeeperSecretsManager
             result.end_pos = notation.length - 1
             result.text = [notation[pos..], notation[pos..]]
           end
-          
+
         when 'record'
           # Record is required - parse until '/' with escaping
           if pos < notation.length
@@ -220,7 +232,7 @@ module KeeperSecretsManager
               result.text = parsed
             end
           end
-          
+
         when 'selector'
           # Selector is required
           if pos < notation.length
@@ -230,7 +242,7 @@ module KeeperSecretsManager
               result.start_pos = pos
               result.end_pos = pos + parsed[1].length - 1
               result.text = parsed
-              
+
               # Check for long selectors that have parameters
               if %w[field custom_field file].include?(parsed[0].downcase)
                 # Parse parameter (field type/label or filename)
@@ -240,13 +252,13 @@ module KeeperSecretsManager
                   plen = param_parsed[1].length
                   plen -= 1 if param_parsed[1].end_with?('[') && !param_parsed[1].end_with?('\\[')
                   result.end_pos += plen
-                  
+
                   # Parse index1 [N] or []
                   index1_parsed = parse_subsection(notation, result.end_pos + 1, '[]', true)
                   if index1_parsed
                     result.index1 = index1_parsed
                     result.end_pos += index1_parsed[1].length
-                    
+
                     # Parse index2 [property]
                     index2_parsed = parse_subsection(notation, result.end_pos + 1, '[]', true)
                     if index2_parsed
@@ -258,80 +270,75 @@ module KeeperSecretsManager
               end
             end
           end
-          
+
         else
           raise NotationError, "Unknown section: #{section_name}"
         end
-        
+
         result
       end
 
       # Parse subsection with delimiters and escaping
       def parse_subsection(text, pos, delimiters, escaped = false)
         return nil if text.nil? || text.empty? || pos < 0 || pos >= text.length
-        
-        if delimiters.nil? || delimiters.length > 2
-          raise NotationError, "Internal error: incorrect delimiters"
-        end
-        
+
+        raise NotationError, 'Internal error: incorrect delimiters' if delimiters.nil? || delimiters.length > 2
+
         token = ''
         raw = ''
-        
+
         while pos < text.length
           if escaped && text[pos] == ESCAPE_CHAR
             # Handle escape sequence
             if pos + 1 >= text.length || !ESCAPE_CHARS.include?(text[pos + 1])
               raise NotationError, "Incorrect escape sequence at position #{pos}"
             end
-            
+
             token += text[pos + 1]
             raw += text[pos, 2]
             pos += 2
           else
             raw += text[pos]
-            
+
             if delimiters.length == 1
               # Single delimiter
               break if text[pos] == delimiters[0]
+
               token += text[pos]
             else
               # Two delimiters (for brackets)
-              if raw[0] != delimiters[0]
-                raise NotationError, "Index sections must start with '['"
-              end
-              
+              raise NotationError, "Index sections must start with '['" if raw[0] != delimiters[0]
+
               if raw.length > 1 && text[pos] == delimiters[0]
                 raise NotationError, "Index sections do not allow extra '[' inside"
               end
-              
+
               if !delimiters.include?(text[pos])
                 token += text[pos]
               elsif text[pos] == delimiters[1]
                 break
               end
             end
-            
+
             pos += 1
           end
         end
-        
+
         # Validate brackets are properly closed
         if delimiters.length == 2
           if raw.length < 2 || raw[0] != delimiters[0] || raw[-1] != delimiters[1]
             raise NotationError, "Index sections must be enclosed in '[' and ']'"
           end
-          
-          if escaped && raw[-2] == ESCAPE_CHAR
-            raise NotationError, "Index sections must be enclosed in '[' and ']'"
-          end
+
+          raise NotationError, "Index sections must be enclosed in '[' and ']'" if escaped && raw[-2] == ESCAPE_CHAR
         end
-        
+
         [token, raw]
       end
 
       # Notation section data class
       class NotationSection
-        attr_accessor :section, :present, :start_pos, :end_pos, 
+        attr_accessor :section, :present, :start_pos, :end_pos,
                       :text, :parameter, :index1, :index2
 
         def initialize(section_name)
@@ -351,4 +358,4 @@ module KeeperSecretsManager
       end
     end
   end
-end
+end

data/lib/keeper_secrets_manager/notation_enhancements.rb

@@ -7,61 +7,59 @@ module KeeperSecretsManager
       # This method extends the basic parse method to handle special cases
       def get_value(notation, options = {})
         value = parse(notation)
-        
+
         # Check if we should process special types
         return value unless options[:auto_process]
-        
+
         # Parse the notation to understand what we're dealing with
         parsed = parse_notation(notation)
         return value if parsed.length < 3
-        
+
         selector = parsed[2].text&.first
         return value unless selector
-        
+
         case selector.downcase
         when 'file'
           # If it's a file and auto_download is enabled, download it
           if options[:auto_download] && value.is_a?(Hash) && value['fileUid']
             begin
               file_data = @secrets_manager.download_file(value['fileUid'])
-              return file_data['data']  # Return file content
-            rescue => e
+              return file_data['data'] # Return file content
+            rescue StandardError => e
               raise NotationError, "Failed to download file: #{e.message}"
             end
           end
-          
+
         when 'field'
           # Check if it's a TOTP field
           parameter = parsed[2].parameter&.first
-          if parameter && parameter.downcase == 'onetimecode' && value.is_a?(String) && value.start_with?('otpauth://')
-            if options[:generate_totp_code]
-              begin
-                totp_params = TOTP.parse_url(value)
-                return TOTP.generate_code(
-                  totp_params['secret'],
-                  algorithm: totp_params['algorithm'],
-                  digits: totp_params['digits'],
-                  period: totp_params['period']
-                )
-              rescue => e
-                raise NotationError, "Failed to generate TOTP code: #{e.message}"
-              end
+          if parameter && parameter.downcase == 'onetimecode' && value.is_a?(String) && value.start_with?('otpauth://') && (options[:generate_totp_code])
+            begin
+              totp_params = TOTP.parse_url(value)
+              return TOTP.generate_code(
+                totp_params['secret'],
+                algorithm: totp_params['algorithm'],
+                digits: totp_params['digits'],
+                period: totp_params['period']
+              )
+            rescue StandardError => e
+              raise NotationError, "Failed to generate TOTP code: #{e.message}"
             end
           end
         end
-        
+
         value
       end
-      
+
       # Convenience method to get TOTP code directly
       def get_totp_code(notation)
         get_value(notation, auto_process: true, generate_totp_code: true)
       end
-      
+
       # Convenience method to download file content directly
       def download_file(notation)
         get_value(notation, auto_process: true, auto_download: true)
       end
     end
   end
-end
+end