keeper_secrets_manager 17.0.4 → 17.2.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,12 @@ 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'.freeze
+
     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}#{KeeperSecretsManager::VERSION}"
     end
-    
+
     # Keeper public keys by ID
     KEEPER_PUBLIC_KEYS = {
       '1' => 'BK9w6TZFxE6nFNbMfIpULCup2a8xc6w2tUTABjxny7yFmxW0dAEojwC6j6zb5nTlmb1dAx8nwo3qF7RPYGmloRM',
@@ -34,7 +26,8 @@ module KeeperSecretsManager
       '14' => 'BJFF8j-dH7pDEw_U347w2CBM6xYM8Dk5fPPAktjib-opOqzvvbsER-WDHM4ONCSBf9O_obAHzCyygxmtpktDuiE',
       '15' => 'BDKyWBvLbyZ-jMueORl3JwJnnEpCiZdN7yUvT0vOyjwpPBCDf6zfL4RWzvSkhAAFnwOni_1tQSl8dfXHbXqXsQ8',
       '16' => 'BDXyZZnrl0tc2jdC5I61JjwkjK2kr7uet9tZjt8StTiJTAQQmnVOYBgbtP08PWDbecxnHghx3kJ8QXq1XE68y8c',
-      '17' => 'BFX68cb97m9_sweGdOVavFM3j5ot6gveg6xT4BtGahfGhKib-zdZyO9pwvv1cBda9ahkSzo1BQ4NVXp9qRyqVGU'
+      '17' => 'BFX68cb97m9_sweGdOVavFM3j5ot6gveg6xT4BtGahfGhKib-zdZyO9pwvv1cBda9ahkSzo1BQ4NVXp9qRyqVGU',
+      '18' => 'BNhngQqTT1bPKxGuB6FhbPTAeNVFl8PKGGSGo5W06xWIReutm6ix6JPivqnbvkydY-1uDQTr-5e6t70G01Bb5JA'
     }.freeze
 
     # Keeper servers by region
@@ -44,16 +37,17 @@ module KeeperSecretsManager
       'AU' => 'keepersecurity.com.au',
       'GOV' => 'govcloud.keepersecurity.us',
       'JP' => 'keepersecurity.jp',
-      'CA' => 'keepersecurity.ca'
+      'CA' => 'keepersecurity.ca',
+      'IL5' => 'il5.keepersecurity.us'
     }.freeze
 
     # 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

@@ -11,42 +11,93 @@ module KeeperSecretsManager
         @secrets_manager = secrets_manager
       end
 
+      def get_notation_results(notation)
+        return [] if notation.nil? || !notation.is_a?(String) || notation.empty?
+
+        parsed = parse_notation(notation)
+        raise NotationError, "Invalid notation: #{notation}" if parsed.length < 3
+
+        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
+
+        records = @secrets_manager.get_secrets([record_token])
+        if records.empty?
+          all     = @secrets_manager.get_secrets
+          records = all.select { |r| r.title == record_token }
+        end
+        records = records.uniq { |r| r.uid } if records.size > 1
+        raise NotationError, "Multiple records match '#{record_token}'" if records.size > 1
+        raise NotationError, "No records match '#{record_token}'"       if records.empty?
+
+        record    = records.first
+        parameter = parsed[2].parameter&.first
+        index1    = parsed[2].index1&.first
+        index2    = parsed[2].index2&.first
+
+        case selector.downcase
+        when 'type'
+          record.type ? [record.type] : []
+        when 'title'
+          record.title ? [record.title] : []
+        when 'notes'
+          (record.notes && !record.notes.empty?) ? [record.notes] : []
+        when 'file'
+          notation_results_file(record, parameter, record_token)
+        when 'field', 'custom_field'
+          notation_results_field(record, parameter, index1, index2, parsed[2])
+        else
+          raise NotationError, "Invalid selector: #{selector}"
+        end
+      end
+
       # Parse notation and return value
       def parse(notation)
-        return nil if notation.nil? || notation.empty?
-        
+        return nil if notation.nil?
+        raise NotationError, 'Invalid notation format: must be a string' unless notation.is_a?(String)
+        return nil if notation.empty?
+
         # 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
-        
+
+        # Remove duplicate UIDs - shortcuts/linked records both shared to same KSM App
+        records = records.uniq { |r| r.uid } if records.size > 1
+
+        # Now check for genuine ambiguity (different records with same title)
         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'
@@ -66,72 +117,135 @@ module KeeperSecretsManager
 
       private
 
+      def value_to_string(v)
+        v.is_a?(String) ? v : v.to_json
+      end
+
+      # Unlike handle_field_selector: no first-element shortcut when no index is given.
+      def notation_results_field(record, parameter, index1, index2, parsed_section)
+        raise NotationError, 'Missing required parameter for field' unless parameter
+
+        field = record.get_field(parameter)
+        raise NotationError, "Field '#{parameter}' not found" unless field
+
+        values = field['value'] || []
+        idx    = parse_index(index1)
+
+        if idx == -1 && index1 && !index1.empty?
+          # index1 is a property name (e.g. [hostName])
+          if values.first.is_a?(Hash)
+            raise NotationError, "Property '#{index1}' not found" unless values.first.key?(index1)
+
+            return [value_to_string(values.first[index1])]
+          else
+            raise NotationError, 'Cannot extract property from non-object value'
+          end
+        end
+
+        raise NotationError, "Field index out of bounds: #{idx} >= #{values.size}" if idx != -1 && idx >= values.size
+
+        selected = idx >= 0 ? [values[idx]] : values
+
+        if index2 && !index2.empty? && index2 != '[]'
+          selected.filter_map do |v|
+            next nil unless v.is_a?(Hash) && v.key?(index2)
+
+            value_to_string(v[index2])
+          end
+        else
+          selected.map { |v| value_to_string(v) }
+        end
+      end
+
+      def notation_results_file(record, parameter, record_token)
+        file = handle_file_selector(record, parameter, record_token)
+
+        file_hash = if file.is_a?(KeeperSecretsManager::Dto::KeeperFile)
+                      {
+                        'fileUid' => file.uid,
+                        'url'     => file.url,
+                        'fileKey' => file.file_key,
+                        'name'    => file.name
+                      }
+                    else
+                      file
+                    end
+
+        content = @secrets_manager.download_file(file_hash)
+        [KeeperSecretsManager::Utils.bytes_to_url_safe_str(content['data'])]
+      end
+
       # 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 +256,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 +278,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 +302,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 +313,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 +322,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 +334,7 @@ module KeeperSecretsManager
               result.text = parsed
             end
           end
-          
+
         when 'selector'
           # Selector is required
           if pos < notation.length
@@ -230,7 +344,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 +354,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 +372,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 +460,4 @@ module KeeperSecretsManager
       end
     end
   end
-end
+end