keeper_secrets_manager 17.0.3 → 17.0.4

data/examples/basic_usage.rb

@@ -1,139 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/keeper_secrets_manager'
-
-# Example: Basic usage of Keeper Secrets Manager Ruby SDK
-
-# Method 1: Initialize with one-time token
-# token = "US:ONE_TIME_TOKEN_HERE"
-# secrets_manager = KeeperSecretsManager.from_token(token)
-
-# Method 2: Initialize with existing config
-config = KeeperSecretsManager::Storage::InMemoryStorage.new({
-  'hostname' => 'keepersecurity.com',
-  'clientId' => 'your-client-id',
-  'privateKey' => 'your-private-key-base64',
-  'appKey' => 'your-app-key-base64'
-})
-secrets_manager = KeeperSecretsManager.new(config: config)
-
-# Get all secrets
-begin
-  records = secrets_manager.get_secrets
-  puts "Found #{records.length} records"
-  
-  records.each do |record|
-    puts "\nRecord: #{record.title}"
-    puts "  Type: #{record.type}"
-    puts "  UID: #{record.uid}"
-    
-    # Access fields dynamically
-    if record.get_field('login')
-      puts "  Login: #{record.get_field_value_single('login')}"
-    end
-    
-    if record.get_field('password')
-      puts "  Password: [HIDDEN]"
-    end
-  end
-rescue => e
-  puts "Error: #{e.message}"
-end
-
-# Get specific record by UID
-begin
-  record_uid = "RECORD_UID_HERE"
-  records = secrets_manager.get_secrets([record_uid])
-  
-  if records.any?
-    record = records.first
-    puts "\nRetrieved record: #{record.title}"
-  end
-rescue => e
-  puts "Error retrieving record: #{e.message}"
-end
-
-# Get record by title
-begin
-  record = secrets_manager.get_secret_by_title("My Login")
-  if record
-    puts "\nFound record by title: #{record.uid}"
-    
-    # Access custom fields
-    record.custom.each do |field|
-      puts "  Custom field '#{field['label']}': #{field['value'].first}"
-    end
-  end
-rescue => e
-  puts "Error: #{e.message}"
-end
-
-# Use notation to access specific field values
-begin
-  # Get password field from a record
-  password = secrets_manager.get_notation("keeper://RECORD_UID/field/password")
-  puts "\nPassword from notation: [HIDDEN]"
-  
-  # Get specific property from complex field
-  hostname = secrets_manager.get_notation("keeper://RECORD_UID/field/host[hostName]")
-  puts "Hostname: #{hostname}"
-  
-  # Get custom field
-  custom_value = secrets_manager.get_notation("keeper://RECORD_UID/custom_field/My Label")
-  puts "Custom field value: #{custom_value}"
-rescue => e
-  puts "Notation error: #{e.message}"
-end
-
-# Create a new record
-begin
-  new_record = KeeperSecretsManager::Dto::KeeperRecord.new(
-    title: 'New Server Login',
-    type: 'login',
-    fields: [
-      { 'type' => 'login', 'value' => ['admin'] },
-      { 'type' => 'password', 'value' => ['SecurePass123!'] },
-      { 'type' => 'url', 'value' => ['https://example.com'] },
-      { 'type' => 'host', 
-        'value' => [{ 'hostName' => '192.168.1.100', 'port' => '22' }],
-        'label' => 'SSH Connection' }
-    ],
-    notes: 'Created by Ruby SDK'
-  )
-  
-  # Create the record
-  # record_uid = secrets_manager.create_secret(new_record)
-  # puts "\nCreated new record: #{record_uid}"
-rescue => e
-  puts "Error creating record: #{e.message}"
-end
-
-# Update existing record
-begin
-  # Get record to update
-  record = secrets_manager.get_secret_by_title("Test Record")
-  
-  if record
-    # Update fields
-    record.set_field('password', 'NewPassword123!')
-    record.notes = "Updated at #{Time.now}"
-    
-    # Save changes
-    # secrets_manager.update_secret(record)
-    # puts "\nRecord updated successfully"
-  end
-rescue => e
-  puts "Error updating record: #{e.message}"
-end
-
-# Working with folders
-begin
-  folders = secrets_manager.get_folders
-  puts "\nFound #{folders.length} folders"
-  
-  folders.each do |folder|
-    puts "  Folder: #{folder.name} (#{folder.uid})"
-  end
-rescue => e
-  puts "Error retrieving folders: #{e.message}"
-end

data/examples/config_string_example.rb

@@ -1,99 +0,0 @@
-#!/usr/bin/env ruby
-
-# Add the Ruby SDK to the load path
-
-require_relative '../lib/keeper_secrets_manager'
-require 'json'
-require 'base64'
-
-puts "=== Using Keeper SDK with Config String ==="
-
-# Example 1: JSON config string
-puts "\n1. Using JSON config string"
-puts "-" * 40
-
-# This would come from your secure configuration
-json_config = {
-  "hostname" => "keepersecurity.com",
-  "clientId" => "YOURCLIENTID",
-  "appKey" => "YOURAPPKEYBASE64",
-  "privateKey" => "YOURPRIVATEKEYBASE64",
-  "appOwnerPublicKey" => "YOUROWNERPUBLICKEYBASE64",
-  "serverPublicKeyId" => "7"
-}.to_json
-
-begin
-  # Initialize with JSON string - NO TOKEN NEEDED!
-  storage = KeeperSecretsManager::Storage::InMemoryStorage.new(json_config)
-  sm = KeeperSecretsManager.new(config: storage)
-  puts "✓ Would connect with pre-configured credentials (if real credentials were provided)"
-rescue => e
-  puts "✗ Expected error with dummy credentials: #{e.message}"
-end
-
-# Example 2: Base64 encoded config
-puts "\n2. Using Base64 encoded config"
-puts "-" * 40
-
-# Encode the config as base64 (like KSM_CONFIG environment variable)
-base64_config = Base64.strict_encode64(json_config)
-puts "Base64 config: #{base64_config[0..50]}..."
-
-begin
-  # Initialize with base64 string - NO TOKEN NEEDED!
-  storage = KeeperSecretsManager::Storage::InMemoryStorage.new(base64_config)
-  sm = KeeperSecretsManager.new(config: storage)
-  puts "✓ Would connect with base64 config (if real credentials were provided)"
-rescue => e
-  puts "✗ Expected error with dummy credentials: #{e.message}"
-end
-
-# Example 3: Using environment variable
-puts "\n3. Using KSM_CONFIG environment variable"
-puts "-" * 40
-
-# Set environment variable (normally done outside the script)
-ENV['KSM_CONFIG'] = base64_config
-
-begin
-  # SDK automatically checks for KSM_CONFIG - NO TOKEN OR CONFIG NEEDED!
-  sm = KeeperSecretsManager.new()
-  puts "✓ Would connect with environment variable (if real credentials were provided)"
-rescue => e
-  puts "✗ Expected error with dummy credentials: #{e.message}"
-end
-
-# Example 4: Real workflow - first time with token, then reuse
-puts "\n4. Real workflow example"
-puts "-" * 40
-
-# First time - use token to get credentials
-puts "First connection with token:"
-puts "sm = KeeperSecretsManager.new(token: 'US:YOUR_TOKEN')"
-puts "config_to_save = sm.config.to_json"
-puts "# Save config_to_save securely"
-
-puts "\nSubsequent connections:"
-puts "saved_config = load_from_secure_storage()"
-puts "storage = KeeperSecretsManager::Storage::InMemoryStorage.new(saved_config)"
-puts "sm = KeeperSecretsManager.new(config: storage)  # No token needed!"
-
-# Example 5: What the config looks like
-puts "\n5. Config structure"
-puts "-" * 40
-puts "After successful token authentication, the config contains:"
-puts JSON.pretty_generate({
-  "clientId" => "Base64 encoded client ID (hash of token)",
-  "appKey" => "Base64 encoded AES key for encryption",
-  "privateKey" => "Base64 encoded EC private key (DER format)",
-  "appOwnerPublicKey" => "Base64 encoded public key for record creation",
-  "hostname" => "keepersecurity.com (or other region)",
-  "serverPublicKeyId" => "7 (or other key ID)"
-})
-
-puts "\n" + "=" * 60
-puts "Key Points:"
-puts "- Once you have the config, you never need the token again"
-puts "- Config can be JSON or base64 encoded"
-puts "- Store the config securely - it contains your encryption keys!"
-puts "- The SDK will NOT ask for a token if valid config is provided"

data/examples/debug_secrets.rb

@@ -1,84 +0,0 @@
-#!/usr/bin/env ruby
-
-# Add the Ruby SDK to the load path
-require_relative '../lib/keeper_secrets_manager'
-
-# Load the SDK
-require 'json'
-
-# Your token
-TOKEN = ENV['KSM_TOKEN'] || 'US:YOUR_ONE_TIME_TOKEN_HERE'
-
-puts "=== Debugging Keeper Secrets Manager ==="
-
-begin
-  # Connect to Keeper with debug logging
-  puts "\n1. Connecting to Keeper..."
-  # Option 1: Use base64 config
-  config_base64 = ENV['KSM_CONFIG_BASE64'] || 'YOUR_BASE64_CONFIG_HERE'
-  storage_from_b64 = KeeperSecretsManager::Storage::InMemoryStorage.new(config_base64)
-  sm = KeeperSecretsManager.new(config: storage_from_b64)
-  # Alternative: Use in-memory storage
-  # storage = KeeperSecretsManager::Storage::InMemoryStorage.new
-  # sm = KeeperSecretsManager.new(token: TOKEN, config: storage)
-  # 
-  # The storage now contains the credentials, so you can reuse it:
-  # sm2 = KeeperSecretsManager.new(config: storage)  # No token needed!
-  
-  # Get all secrets with raw response
-  puts "\n2. Fetching secrets (this calls the internal method)..."
-  
-  # Let's look at what the SDK is actually doing internally
-  # Get the raw response to see what's coming from the server
-  response = sm.instance_eval do
-    fetch_and_decrypt_secrets
-  end
-  
-  puts "\n3. Response Analysis:"
-  puts "   - Total records returned: #{response[:records].length}"
-  puts "   - Total folders returned: #{response[:folders].length}"
-  puts "   - Warnings: #{response[:warnings]}"
-  
-  # Check if there are any records at all
-  if response[:records].empty?
-    puts "\n   ⚠️  No Secrets Manager-compatible records found!"
-    puts "   The warning indicates you have 4 'general' type records."
-    puts "   These are not accessible via the Secrets Manager SDK."
-  else
-    puts "\n4. Records found:"
-    response[:records].each_with_index do |record, i|
-      puts "   #{i+1}. #{record.title} (Type: #{record.type}, UID: #{record.uid})"
-    end
-  end
-  
-  # Try to get records with specific UIDs from the warning
-  puts "\n5. Attempting to fetch specific UIDs from warning..."
-  warning_uids = ['AwOCl5W2RubtkFSuL72jXg', 'bX7uYVNsujLoPjrvEFA3Rg', 'gSnSFvd_UI9CnK_5kSZ85Q', 'wIT61_GnuBIpUOPxOrgPeQ']
-  
-  warning_uids.each do |uid|
-    begin
-      records = sm.get_secrets([uid])
-      if records.any?
-        puts "   ✓ Found: #{uid}"
-      else
-        puts "   ✗ Not accessible: #{uid} (general type)"
-      end
-    rescue => e
-      puts "   ✗ Error fetching #{uid}: #{e.message}"
-    end
-  end
-  
-  puts "\n6. Summary:"
-  puts "   - Your vault contains 'general' type records"
-  puts "   - These are legacy Keeper records not designed for API access"
-  puts "   - To use Secrets Manager, create records with specific types like:"
-  puts "     • login"
-  puts "     • databaseCredentials"
-  puts "     • sshKeys"
-  puts "     • serverCredentials"
-  puts "     • etc."
-  
-rescue => e
-  puts "\nError: #{e.message}"
-  puts e.backtrace.first(5).join("\n")
-end

data/examples/demo_list_secrets.rb

@@ -1,182 +0,0 @@
-#!/usr/bin/env ruby
-
-# This script demonstrates the Ruby SDK by listing all secrets in your vault
-# It uses the real config.base64 file to connect to Keeper
-
-require_relative 'lib/keeper_secrets_manager'
-require 'base64'
-require 'json'
-
-puts "=== Keeper Secrets Manager Ruby SDK Demo ==="
-puts "Connecting to Keeper and listing all secrets..."
-puts
-
-begin
-  # Load the real configuration
-  config_file = File.expand_path('config.base64', __dir__)
-  unless File.exist?(config_file)
-    puts "Error: config.base64 not found at #{config_file}"
-    exit 1
-  end
-
-  config_base64 = File.read(config_file).strip
-  config_json = Base64.decode64(config_base64)
-  config_data = JSON.parse(config_json)
-
-  # Display connection info (partial)
-  puts "Configuration loaded:"
-  puts "  Hostname: #{config_data['hostname']}"
-  puts "  Client ID: #{config_data['clientId'][0..30]}..."
-  puts "  Has appKey: #{config_data.key?('appKey')}"
-  puts "  Has privateKey: #{config_data.key?('privateKey')}"
-  puts "  Has serverPublicKeyId: #{config_data['serverPublicKeyId']}"
-  puts
-
-  # Create storage and SDK instance
-  storage = KeeperSecretsManager::Storage::InMemoryStorage.new(config_data)
-  
-  # Enable debug logging
-  require 'logger'
-  logger = Logger.new(STDOUT)
-  logger.level = Logger::DEBUG
-  
-  secrets_manager = KeeperSecretsManager.new(config: storage, logger: logger, log_level: Logger::DEBUG)
-
-  # Get all secrets
-  puts "Fetching all secrets..."
-  records = secrets_manager.get_secrets
-  
-  if records.empty?
-    puts "\nNo secrets found in the vault."
-  else
-    puts "\nFound #{records.length} secret(s):"
-    puts "-" * 80
-    
-    records.each_with_index do |record, index|
-      puts "\n#{index + 1}. #{record.title}"
-      puts "   UID: #{record.uid}"
-      puts "   Type: #{record.type}"
-      
-      # Show fields (hide sensitive values)
-      if record.fields.any?
-        puts "   Fields:"
-        record.fields.each do |field|
-          field_type = field['type']
-          field_label = field['label'] ? " (#{field['label']})" : ""
-          
-          # Show field info but mask sensitive data
-          case field_type
-          when 'login', 'email'
-            value = record.get_field_value_single(field_type)
-            puts "     - #{field_type}#{field_label}: #{value}"
-          when 'password', 'secret', 'privateKey'
-            puts "     - #{field_type}#{field_label}: [HIDDEN]"
-          when 'url'
-            values = record.get_field_value(field_type)
-            if values.length == 1
-              puts "     - #{field_type}#{field_label}: #{values.first}"
-            else
-              puts "     - #{field_type}#{field_label}: #{values.length} URLs"
-            end
-          when 'host'
-            host = record.get_field_value_single(field_type)
-            if host.is_a?(Hash)
-              puts "     - #{field_type}#{field_label}: #{host['hostName']}:#{host['port'] || '22'}"
-            end
-          when 'phone'
-            phone = record.get_field_value_single(field_type)
-            if phone.is_a?(Hash)
-              puts "     - #{field_type}#{field_label}: #{phone['number']} (#{phone['region']})"
-            end
-          when 'name'
-            name = record.get_field_value_single(field_type)
-            if name.is_a?(Hash)
-              full_name = [name['first'], name['middle'], name['last']].compact.join(' ')
-              puts "     - #{field_type}#{field_label}: #{full_name}"
-            end
-          else
-            puts "     - #{field_type}#{field_label}: [#{field['value']&.length || 0} value(s)]"
-          end
-        end
-      end
-      
-      # Show custom fields
-      if record.custom.any?
-        puts "   Custom Fields:"
-        record.custom.each do |field|
-          label = field['label'] || field['type']
-          value_count = field['value']&.length || 0
-          puts "     - #{label}: [#{value_count} value(s)]"
-        end
-      end
-      
-      # Show notes (first 50 chars)
-      if record.notes && !record.notes.empty?
-        notes_preview = record.notes[0..50]
-        notes_preview += "..." if record.notes.length > 50
-        puts "   Notes: #{notes_preview}"
-      end
-      
-      # Show file count
-      if record.files && record.files.any?
-        puts "   Files: #{record.files.length} attachment(s)"
-      end
-    end
-    
-    puts "\n" + "-" * 80
-  end
-
-  # Get folders
-  puts "\nFetching folders..."
-  folders = secrets_manager.get_folders
-  
-  if folders.empty?
-    puts "No folders found."
-  else
-    puts "Found #{folders.length} folder(s):"
-    folders.each do |folder|
-      puts "  - #{folder.name} (#{folder.uid})"
-    end
-  end
-
-  # Demonstrate notation
-  if records.any?
-    puts "\n" + "=" * 80
-    puts "Notation Examples (using first record):"
-    puts "=" * 80
-    
-    first_record = records.first
-    
-    # Try various notations
-    notations = [
-      "keeper://#{first_record.uid}/type",
-      "keeper://#{first_record.uid}/title",
-      "keeper://#{first_record.uid}/field/login"
-    ]
-    
-    notations.each do |notation|
-      begin
-        value = secrets_manager.get_notation(notation)
-        puts "#{notation}"
-        puts "  => #{value}"
-      rescue => e
-        puts "#{notation}"
-        puts "  => Error: #{e.message}"
-      end
-    end
-  end
-
-  puts "\n✅ SDK is working correctly!"
-  puts "\nCapabilities demonstrated:"
-  puts "- ✓ Connected to Keeper"
-  puts "- ✓ Retrieved all secrets"
-  puts "- ✓ Accessed field values"
-  puts "- ✓ Listed folders"
-  puts "- ✓ Notation parsing"
-
-rescue => e
-  puts "\n❌ Error: #{e.class} - #{e.message}"
-  puts "\nBacktrace:"
-  puts e.backtrace.first(5).join("\n")
-  exit 1
-end

data/examples/download_files.rb

@@ -1,100 +0,0 @@
-#!/usr/bin/env ruby
-
-# Add the Ruby SDK to the load path
-$LOAD_PATH.unshift('/Users/mustinov/Source/secrets-manager/sdk/ruby/lib')
-
-# Load the SDK
-require 'keeper_secrets_manager'
-require 'fileutils'
-
-# Helper method to sanitize filename
-def sanitize_filename(filename)
-  # Remove or replace invalid characters
-  filename.gsub(/[<>:"|?*\/\\]/, '_').strip
-end
-
-begin
-  # Connect to Keeper
-  puts "Connecting to Keeper..."
-  # IMPORTANT: Replace with your own configuration
-  # Option 1: Use one-time token
-  # token = 'US:YOUR_ONE_TIME_TOKEN_HERE'
-  # sm = KeeperSecretsManager.from_token(token)
-  #
-  # Option 2: Use base64 config
-  config_base64 = ENV['KSM_CONFIG_BASE64'] || 'YOUR_BASE64_CONFIG_HERE'
-  storage_from_b64 = KeeperSecretsManager::Storage::InMemoryStorage.new(config_base64)
-  sm = KeeperSecretsManager.new(config: storage_from_b64)
-
-  # Get all secrets
-  puts "\nFetching secrets..."
-  response = sm.get_secrets(full_response: true)
-  secrets = response.records
-
-  # Find secrets with files
-  secrets_with_files = secrets.select { |s| s.files && s.files.any? }
-  
-  if secrets_with_files.empty?
-    puts "\nNo secrets with files found."
-    exit
-  end
-
-  puts "\nFound #{secrets_with_files.length} secrets with files:"
-  
-  # Create downloads directory
-  download_dir = "downloads"
-  FileUtils.mkdir_p(download_dir)
-  
-  total_files = 0
-  downloaded_files = 0
-  failed_files = 0
-  
-  secrets_with_files.each do |secret|
-    puts "\n📁 #{secret.title} (#{secret.files.length} files)"
-    
-    secret.files.each do |file|
-      total_files += 1
-      file_name = file['title'] || file['name'] || 'unnamed'
-      file_size = file['size'] || 0
-      file_uid = file['fileUid'] || file['uid']
-      
-      print "   - #{file_name} (#{file_size} bytes) ... "
-      
-      if file_uid
-        begin
-          # Download the file (pass the whole file object)
-          downloaded_file = sm.download_file(file)
-          
-          # Create subdirectory for the secret
-          secret_dir = File.join(download_dir, sanitize_filename(secret.title))
-          FileUtils.mkdir_p(secret_dir)
-          
-          # Save the file (sanitize the filename to remove path components)
-          safe_filename = File.basename(downloaded_file['name'] || file_name)
-          file_path = File.join(secret_dir, safe_filename)
-          File.binwrite(file_path, downloaded_file['data'])
-          
-          downloaded_files += 1
-          puts "✅ Saved"
-        rescue => e
-          failed_files += 1
-          puts "❌ Failed: #{e.message}"
-        end
-      else
-        failed_files += 1
-        puts "❌ No file UID"
-      end
-    end
-  end
-  
-  puts "\n" + "=" * 60
-  puts "Download Summary:"
-  puts "  Total files: #{total_files}"
-  puts "  ✅ Downloaded: #{downloaded_files}"
-  puts "  ❌ Failed: #{failed_files}"
-  puts "\nFiles saved to: #{File.expand_path(download_dir)}/"
-  
-rescue => e
-  puts "\nError: #{e.message}"
-  puts e.backtrace
-end

data/examples/flexible_records_example.rb

@@ -1,94 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/keeper_secrets_manager'
-
-# Example showing flexible record creation in multiple ways
-
-# Method 1: Direct hash-based creation (JavaScript-style)
-record1 = KeeperSecretsManager::Dto::KeeperRecord.new(
-  title: 'My Login',
-  type: 'login',
-  fields: [
-    { 'type' => 'login', 'value' => ['my_username'] },
-    { 'type' => 'password', 'value' => ['my_password'] },
-    { 'type' => 'url', 'value' => ['https://example.com'] },
-    { 
-      'type' => 'host', 
-      'value' => [{ 'hostName' => '192.168.1.1', 'port' => '8080' }],
-      'label' => 'Custom Host'
-    }
-  ],
-  custom: [
-    {
-      'type' => 'phone',
-      'value' => [{ 'region' => 'US', 'number' => '555-1234' }],
-      'label' => 'Work Phone'
-    }
-  ],
-  notes: 'Example login record'
-)
-
-# Method 2: Using field helpers (optional convenience)
-record2 = KeeperSecretsManager::Dto::KeeperRecord.new(
-  title: 'My Server',
-  type: 'sshKeys'
-)
-
-# Add fields dynamically
-record2.set_field('login', 'root')
-record2.set_field('sshKey', { 
-  'privateKey' => '-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----',
-  'publicKey' => 'ssh-rsa AAAAB3...'
-})
-
-# Method 3: Using dynamic accessors (Ruby magic)
-record3 = KeeperSecretsManager::Dto::KeeperRecord.new(
-  title: 'Dynamic Record',
-  type: 'login'
-)
-
-# These create fields dynamically!
-record3.login = 'john_doe'
-record3.password = 'secure_pass123'
-record3.url = 'https://myapp.com'
-
-# Method 4: Mixing approaches
-record4 = KeeperSecretsManager::Dto::KeeperRecord.new(
-  title: 'Payment Info',
-  type: 'bankCard'
-)
-
-# Use helper for complex field
-card_field = KeeperSecretsManager::FieldTypes::Helpers.payment_card(
-  number: '4111111111111111',
-  expiration_date: '12/25',
-  security_code: '123',
-  cardholder_name: 'John Doe'
-)
-
-# Add to record
-record4.fields << card_field.to_h
-
-# Add custom field with any structure
-record4.set_field('customData', {
-  'someKey' => 'someValue',
-  'nested' => {
-    'data' => 'structure'
-  }
-}, 'My Custom Data', true)  # true = custom field
-
-# Access field values
-puts "Login: #{record1.get_field_value_single('login')}"
-puts "Password field: #{record1.get_field('password')}"
-puts "All custom fields: #{record1.custom}"
-
-# Dynamic accessor
-puts "URL from record3: #{record3.url}"
-
-# Access complex field values
-host_field = record1.get_field_value_single('host')
-puts "Host: #{host_field['hostName']}:#{host_field['port']}" if host_field
-
-# Convert to hash for API
-puts "\nRecord as hash for API:"
-puts record1.to_h.to_json