From c08f480bbee11441962c759e9574f8812d76bea6 Mon Sep 17 00:00:00 2001
From: OSXLich-Doug <doug@play.net>
Date: Tue, 17 Jun 2025 21:49:25 -0400
Subject: [PATCH 1/5] feat(gs): DRAFT  new elogin 5.12 +

This proposal for a new elogin comes with some particulars.  Please check 'other scripts' channel for details and helpful hints.
---
 scripts/elogin.lic | 698 +++++++++++++++++++++++++++++----------------
 1 file changed, 450 insertions(+), 248 deletions(-)

diff --git a/scripts/elogin.lic b/scripts/elogin.lic
index a105bd477..08002347e 100644
--- a/scripts/elogin.lic
+++ b/scripts/elogin.lic
@@ -1,287 +1,489 @@
 =begin
-    elogin.lic: A script for logging into other characters from within lich.
-
-    Useful for switching characters or logging into characters on other accounts.
-
-    This script uses the same entry.dat as lich.rbw.
-    list/add/modify/delete commands are available to modify the entry.dat from within the script.
-
-    You have the option of running a script(s) at startup.
-
-    Please see ;elogin help for additional informaiton.
-
-             author: elanthia-online
-       contributors: Phalen33
-               game: Gemstone
-               tags: login
-           required: Lich > 5.0.1
-            version: 1.2.3
-
-  1.2.3 (2024-12-02)
-    - Wrap RUBY & LICH location path in quotes incase of spaces in path
-  1.2.2 (2024-11-24)
-    - Remove references to ;trust script, deprecated
-  1.2.1 (2024-10-10)
-    - Anchor regex comparisons and convert to_s
-  1.2.0 (2024-07-22)
-    - Add support for GSTest instance
-  1.1.3 (2023-11-15)
-    - Change ruby process launching from using system() to Process.spawn()
-  1.1.2 (2023-03-28)
-    - Change from using SAL login method to native character saved entry CLI login method
-  1.1.1 (2023-01-23)
-    - Update for Ruby v3 compatibility
-  1.1.0 (2022-02-01)
-    - Fix for Wrayth login method
-    - Add Lich version check
-  1.0.0 (2015-09-19)
-    - Initial release
+  e_elogin.lic – Character launcher for Lich 5+
+  Uses fallback-aware LoginHelpers to select best character entry and spawn login.
+  
+  Usage:
+    ;elogin help                       # Show usage
+    ;elogin set realm <prime|platinum|shattered|test>  # Set game realm
+    ;elogin <char> [script1,script2]  # Login with optional scripts
+    ;elogin add <char> <user_id> <password>  # Add character entry
+    ;elogin delete <char> <game_code>        # Delete character entry
 =end
 
 LICH_GEM_REQUIRES = '5.0.1'
 
 if Gem::Version.new(LICH_VERSION) < Gem::Version.new(LICH_GEM_REQUIRES)
-  if $frontend == 'stormfront' || $frontend == 'profanity'
-    _respond "\<preset id=\"speech\"\>" + "########################################" + "\<\/preset\>"
-    _respond "\<preset id=\"thought\"\>" + "Script:#{script.name} now requires a newer version of Lich(#{LICH_GEM_REQUIRES}+) to run." + "\<\/preset\>"
-    _respond "\<preset id=\"thought\"\>" + "Please update to a newer version." + "\<\/preset\>"
-    _respond ""
-    _respond "\<preset id=\"thought\"\>" + "Currently Running Lich Version: #{Gem::Version.new(LICH_VERSION)}" + "\<\/preset\>"
-    _respond "\<preset id=\"thought\"\>" + "For help updating visit: https://gswiki.play.net/Lich_(software)/Installation" + "\<\/preset\>"
-    _respond "\<preset id=\"speech\"\>" + "########################################" + "\<\/preset\>"
-  else
-    _respond "##" + "########################################"
-    _respond ">" + "Script:#{script.name} now requires a newer version of Lich(#{LICH_GEM_REQUIRES}+) to run."
-    _respond ">" + "Please update to a newer version."
-    _respond ">" + ""
-    _respond ">" + "Currently Running Lich Version: #{Gem::Version.new(LICH_VERSION)}"
-    _respond ">" + "For help updating visit: https://gswiki.play.net/Lich_(software)/Installation"
-    _respond "##" + "########################################"
-  end
+  echo "elogin.lic requires Lich v#{LICH_GEM_REQUIRES}+."
   exit
 end
 
-if script.vars[1].nil? || script.vars[1].to_s =~ /^help$/i
-  echo "elogin.lic: A script for logging into other characters from within lich"
-  echo
-  echo "You must first set a realm for use with the script commands."
-  echo ";elogin set realm <prime, platinum, shattered, test>"
-  echo
-  echo "Your frontend setting will be set using your current client (wizard or Wrayth)"
-  echo "when using the add or modify command"
-  echo
-  echo "This script uses the same entry.dat file as the quick game entry in lich.rbw."
-  echo "You can add character information using lich.rbw by saving the information for quick game entry."
-  echo "You can also use this scripts add/delete/modify options for managing saved character information."
-  echo
-  echo "List all characters saved in the entry.dat,"
-  echo ";elogin list"
-  echo
-  echo "Add a character\'s information to the entry.dat file,"
-  echo ";elogin add <character name> <account> <password>"
-  echo
-  echo "Delete a character from the entry.dat file,"
-  echo ";elogin delete <character name>"
-  echo
-  echo "Modify the login information for an existing character,"
-  echo ";elogin modify <character name> <account> <password>"
-  echo
-  echo "Login as a character using saved account information"
-  echo ";elogin <character name>"
-  echo
-  echo "Login as a character and run a script after logging in."
-  echo "Multiple scripts can be run by seperating names with a comma."
-  echo ";elogin <character name> <script>"
-  echo ";elogin <character name> <script1,script2,script3...>"
-  exit
-elsif script.vars[1].to_s =~ /^set$/i
-  if script.vars[2].to_s =~ /^realm$/i
-    if script.vars[3].to_s =~ /^(?:platinum|shattered|prime|test)$/
-      CharSettings['realm'] = script.vars[3].downcase
-      echo 'setting saved'
-      exit
-    else
-      echo 'Error: The only allowed values are prime, platinum, or shattered.'
-      exit
-    end
+# ============================================================================
+# HELPER METHODS
+# ============================================================================
+
+def lich_version_at_least?(major, minor = 0, patch = 0)
+  return false unless defined?(LICH_VERSION)
+  current = LICH_VERSION.scan(/\d+/).map(&:to_i)
+  target = [major, minor, patch]
+  (current <=> target) >= 0
+end
+
+def debug_log(message)
+  return unless ENV['ELOGIN_DEBUG'] == 'true'
+  echo "DEBUG: #{message}"
+end
+
+def handle_error(message, should_exit: true)
+  echo message
+  Lich.log "elogin error: #{message}" if defined?(Lich)
+  exit if should_exit
+end
+
+def log_operation(message)
+  Lich.log "elogin: #{message}" if defined?(Lich)
+end
+
+def login_backend_version
+  lich_version_at_least?(5, 12, 0) ? :yaml : :dat
+end
+
+def load_entry_data
+  case login_backend_version
+  when :yaml
+    load_yaml_entries
+  when :dat
+    load_dat_entries
   end
-elsif script.vars[1].to_s =~ /^list$/i
-  if File.exist?(File.join(DATA_DIR, "entry.dat"))
-    entry_data = File.open(File.join(DATA_DIR, "entry.dat"), 'r') { |file|
-      begin
-        Marshal.load(file.read.unpack('m').first)
-      rescue
-        Array.new
-      end
-    }
-  else
-    entry_data = Array.new
+end
+
+def load_yaml_entries
+  yaml_path = Lich::Common::GUI::YamlState.yaml_file_path(DATA_DIR)
+  debug_log("Looking for YAML file at: #{yaml_path}")
+  debug_log("YAML file exists: #{File.exist?(yaml_path)}")
+  
+  handle_error("Error: no saved entries YAML file found at #{yaml_path}") unless File.exist?(yaml_path)
+  
+  begin
+    raw_yaml = YAML.load_file(yaml_path)
+    debug_log("Raw YAML loaded: #{raw_yaml.class} with keys: #{raw_yaml.keys if raw_yaml.respond_to?(:keys)}")
+    debug_log("Raw YAML accounts: #{raw_yaml['accounts']}")
+    
+    # Skip symbolize_keys - it's corrupting the data
+    # symbolized_yaml = Lich::Util::LoginHelpers.symbolize_keys(raw_yaml)
+    # debug_log("Symbolized YAML: #{symbolized_yaml.class}")
+    # debug_log("Symbolized YAML accounts: #{symbolized_yaml[:accounts]}")
+    
+    legacy_format = Lich::Common::GUI::YamlState.convert_yaml_to_legacy_format(raw_yaml)
+    debug_log("Legacy format result: #{legacy_format.class} with #{legacy_format.length} entries")
+    
+    legacy_format
+  rescue => e
+    debug_log("Error in YAML loading: #{e.class} - #{e.message}")
+    handle_error("Error loading entry.yaml: #{e.class} - #{e.message}")
   end
+end
 
-  entry_data.each { |login_info|
-    if login_info[:game_code] == 'GSX'
-      realm = 'platinum'
-    elsif login_info[:game_code] == 'GSF'
-      realm = 'shattered'
-    elsif login_info[:game_code] == 'GST'
-      realm = 'test'
-    else
-      realm = 'prime'
-    end
-    echo "#{login_info[:char_name]} #{login_info[:user_id]} #{login_info[:password]} #{realm} #{login_info[:frontend]}"
-  }
-  exit
-elsif script.vars[1].to_s =~ /^(?:add|delete|modify)$/i
-  if CharSettings['realm']
-    realm = CharSettings['realm']
-  else
-    echo "Error: realm not set."
-    echo "Please use ;elogin set realm <prime, platinum, shattered, test>"
-    exit
+def load_dat_entries
+  entry_file = File.join(DATA_DIR, 'entry.dat')
+  handle_error("Error: entry.dat not found. Set up a character via the Lich front-end or wait for YAML support.") unless File.exist?(entry_file)
+  
+  begin
+    raw = File.read(entry_file)
+    decoded = raw.unpack1('m')
+    Marshal.load(decoded)
+  rescue => e
+    handle_error("Error loading entry.dat: #{e.class} - #{e.message}")
   end
-  if script.vars[1].to_s =~ /^(?:add|modify)$/i && (script.vars[2].nil? || script.vars[3].nil? || script.vars[4].nil?)
-    echo "Error: Please use the syntax ;elogin add/modify <character name> <account name> <password>"
-    echo "See ;elogin help for more information."
-    exit
-  elsif script.vars[1].to_s =~ /^delete$/i && script.vars[2].nil?
-    echo "Error: Please use the syntax ;elogin delete <character name>"
-    echo "See ;elogin help for more information."
-    exit
-  else
-    if File.exist?(File.join(DATA_DIR, "entry.dat"))
-      entry_data = File.open(File.join(DATA_DIR, "entry.dat"), 'r') { |file|
-        begin
-          Marshal.load(file.read.unpack('m').first)
-        rescue
-          Array.new
-        end
-      }
-    else
-      entry_data = Array.new
+end
+
+def save_entry_data(entry_data)
+  # Debug: Show what we're trying to save
+  debug_log("About to save #{entry_data.length} entries")
+  entry_data.each_with_index do |entry, i|
+    debug_log("Entry #{i}: #{entry[:char_name]} (#{entry[:game_code]})")
+  end
+  
+  case login_backend_version
+  when :yaml
+    # For YAML, save_entries expects Array in legacy format and handles conversion internally
+    success = Lich::Common::GUI::YamlState.save_entries(DATA_DIR, entry_data)
+    debug_log("Save result: #{success}")
+    handle_error("Error: Failed to save to entry.yaml") unless success
+  when :dat
+    begin
+      raw = Marshal.dump(entry_data)
+      encoded = [raw].pack('m')
+      File.write(File.join(DATA_DIR, 'entry.dat'), encoded)
+    rescue => e
+      handle_error("Error: Failed to save to entry.dat - #{e.class}: #{e.message}")
     end
+  end
+end
 
-    char_name = script.vars[2].capitalize
-    user_id = script.vars[3].downcase
-    password = script.vars[4]
-    game_name = 'GemStone IV'
-    frontend = $frontend
-    custom_launch = nil
-    custom_launch_dir = nil
-
-    if realm == 'platinum'
-      game_code = 'GSX'
-    elsif realm == 'shattered'
-      game_code = 'GSF'
-    elsif realm == 'test'
-      game_code = 'GST'
+def resolve_login_helpers_paths(mode = 'production')
+  handle_error("Unsupported Lich version: #{LICH_VERSION}") unless lich_version_at_least?(5, 6, 2)
+  
+  case mode
+  when "production"
+    remote_repo = "https://raw.githubusercontent.com/elanthia-online/lich-5/master/lib"
+  when "beta"
+    remote_repo = "https://raw.githubusercontent.com/elanthia-online/lich-5/staging/lib"
+  when "alpha"
+    local_test_base = ENV['LICH_DEV']
+    handle_error("LICH_DEV environment variable not set for alpha mode") unless local_test_base && !local_test_base.strip.empty?
+    
+    local_test_base = File.expand_path(File.join(local_test_base, "lib"))
+    
+    if lich_version_at_least?(5, 11, 0)
+      source_path = File.join(local_test_base, 'util', 'login_helpers.rb')
+      local_path = File.join(LIB_DIR, 'util', 'login_helpers.rb')
+      require_path = File.join(LIB_DIR, 'util', 'login_helpers')
     else
-      game_code = 'GS3'
+      source_path = File.join(local_test_base, 'login_helpers.rb')
+      local_path = File.join(LIB_DIR, 'login_helpers.rb')
+      require_path = File.join(LIB_DIR, 'login_helpers')
     end
+    
+    return { local_path: local_path, require_path: require_path, source_path: source_path, remote_url: nil }
+  else
+    handle_error("Unknown mode: #{mode.inspect}")
+  end
 
-    data = entry_data.find { |d| (d[:char_name] == char_name) and (d[:game_code] == game_code) }
+  if lich_version_at_least?(5, 11, 0)
+    local_path = File.join(LIB_DIR, 'util', 'login_helpers.rb')
+    require_path = File.join(LIB_DIR, 'util', 'login_helpers')
+  else
+    local_path = File.join(LIB_DIR, 'login_helpers.rb')
+    require_path = File.join(LIB_DIR, 'login_helpers')
+  end
 
-    if script.vars[1].to_s =~ /^add$/i
-      if data
-        echo "Error: Add failed.  Character information already exists."
-        echo "Please use delete to remove character or modify to update account information"
-        exit
-      else
-        h = { :char_name => char_name, :game_code => game_code, :game_name => game_name, :user_id => user_id, :password => password, :frontend => frontend, :custom_launch => custom_launch, :custom_launch_dir => custom_launch_dir }
-        entry_data.push(h)
-      end
-    end
+  remote_url = "#{remote_repo}/util/login_helpers.rb"
+  { local_path: local_path, require_path: require_path, remote_url: remote_url }
+end
 
-    if script.vars[1].to_s =~ /^delete$/i
-      if data
-        entry_data.delete(data)
-        echo "Character deleted."
-      else
-        echo "Error Character does not exist."
-        exit
+def ensure_login_helpers_loaded(mode = 'production')
+  paths = resolve_login_helpers_paths(mode)
+  
+  unless File.exist?(paths[:local_path])
+    if paths[:source_path] && File.exist?(paths[:source_path])
+      FileUtils.mkdir_p(File.dirname(paths[:local_path]))
+      FileUtils.cp(paths[:source_path], paths[:local_path])
+    elsif paths[:remote_url]
+      begin
+        require 'open-uri'
+        content = URI.open(paths[:remote_url], &:read)
+        FileUtils.mkdir_p(File.dirname(paths[:local_path]))
+        File.write(paths[:local_path], content)
+      rescue => e
+        handle_error("Failed to download login_helpers.rb from #{paths[:remote_url]}: #{e.message}")
       end
+    else
+      handle_error("No valid source found to populate login_helpers.rb")
     end
+  end
 
-    if script.vars[1].to_s =~ /^modify$/i
-      if data
-        entry_data.delete(data)
-        h = { :char_name => char_name, :game_code => game_code, :game_name => game_name, :user_id => user_id, :password => password, :frontend => frontend, :custom_launch => custom_launch, :custom_launch_dir => custom_launch_dir }
-        entry_data.push(h)
-        echo "Character information updated."
-      else
-        echo "Error Character does not exist."
-        exit
-      end
-    end
-    File.open(File.join(DATA_DIR, "entry.dat"), 'w') { |file|
-      file.write([Marshal.dump(entry_data)].pack('m'))
-    }
-    exit
+  require paths[:require_path]
+end
+
+def add_login_entry(entry_data, char_name:, user_id:, password:, game_code: nil, game_name: 'GemStone IV', frontend: $frontend, custom_launch: nil, custom_launch_dir: nil)
+  handle_error("Fatal: entry_data was not loaded correctly. Got #{entry_data.class} instead of Array.") unless entry_data.is_a?(Array)
+
+  # Debug: Show what we loaded
+  debug_log("Loaded #{entry_data.length} existing entries")
+  entry_data.each_with_index do |entry, i|
+    debug_log("Existing Entry #{i}: #{entry[:char_name]} (#{entry[:game_code]})")
   end
-else
-  char_name = script.vars[1].capitalize
-  if script.vars[2]
-    start_script = script.vars[2]
+
+  game_code ||= case CharSettings['realm']
+                when 'platinum' then 'GSX'
+                when 'shattered' then 'GSF'
+                when 'test' then 'GST'
+                else 'GS3'
+                end
+
+  existing = entry_data.find { |d| d[:char_name] == char_name && d[:game_code] == game_code }
+  if existing
+    handle_error("Error: Add failed. Character already exists for #{char_name} (#{game_code}). Use `modify` to update or `delete` to remove existing entry.")
   end
-end
 
-if CharSettings['realm']
-  realm = CharSettings['realm']
-else
-  echo "Error: realm not set."
-  echo "Please use ;elogin set realm <prime, platinum, shattered, test."
-  exit
+  # Use exact structure from original legacy code
+  h = { 
+    :char_name => char_name, 
+    :game_code => game_code, 
+    :game_name => game_name, 
+    :user_id => user_id.downcase, 
+    :password => password, 
+    :frontend => frontend, 
+    :custom_launch => custom_launch, 
+    :custom_launch_dir => custom_launch_dir 
+  }
+  entry_data.push(h)
+
+  debug_log("After adding new entry, total entries: #{entry_data.length}")
+
+  save_entry_data(entry_data)
+  log_operation("Added login entry for #{char_name} (#{game_code}) with account #{user_id}")
+  echo "Successfully added login entry for #{char_name} (#{game_code})."
 end
 
-if File.exist?(File.join(DATA_DIR, "entry.dat"))
-  entry_data = File.open(File.join(DATA_DIR, "entry.dat"), 'r') { |file|
-    begin
-      Marshal.load(file.read.unpack('m').first)
-    rescue
-      Array.new
-    end
+def modify_login_entry(entry_data, char_name:, user_id:, password:)
+  handle_error("Fatal: entry_data was not loaded correctly. Got #{entry_data.class} instead of Array.") unless entry_data.is_a?(Array)
+
+  # Find existing entry by character name AND account (user_id)
+  existing = entry_data.find { |d| d[:char_name].casecmp?(char_name) && d[:user_id].casecmp?(user_id) }
+  
+  unless existing
+    echo "Modify failed. No entry found for character: #{char_name} with account: #{user_id}"
+    echo "Existing characters:"
+    entry_data.each { |entry| echo "  #{entry[:char_name]} (#{entry[:game_code]}) - #{entry[:user_id]}" }
+    handle_error("Character/account combination not found.")
+  end
+
+  debug_log("Found existing entry: #{existing}")
+
+  # Remove the old entry
+  entry_data.reject! { |d| d[:char_name].casecmp?(char_name) && d[:user_id].casecmp?(user_id) }
+  
+  # Create new entry with updated password but preserve other fields
+  h = { 
+    :char_name => existing[:char_name], 
+    :game_code => existing[:game_code], 
+    :game_name => existing[:game_name], 
+    :user_id => user_id.downcase, 
+    :password => password, 
+    :frontend => existing[:frontend], 
+    :custom_launch => existing[:custom_launch], 
+    :custom_launch_dir => existing[:custom_launch_dir] 
   }
-else
-  echo 'Error: No saved account information found.'
-  echo 'Please use the add function to add your character\'s account information.'
-  echo 'Use ;elogin help for more information.'
+  entry_data.push(h)
+
+  save_entry_data(entry_data)
+  log_operation("Modified login entry for #{char_name} with account #{user_id}")
+  echo "Successfully modified login entry for #{char_name} with account #{user_id}."
 end
 
-if realm == 'platinum'
-  data = entry_data.find { |d| (d[:char_name] == char_name) and (d[:game_code] == 'GSX') }
-elsif realm == 'shattered'
-  data = entry_data.find { |d| (d[:char_name] == char_name) and (d[:game_code] == 'GSF') }
-elsif realm == 'test'
-  data = entry_data.find { |d| (d[:char_name] == char_name) and (d[:game_code] == 'GST') }
-else
-  data = entry_data.find { |d| (d[:char_name] == char_name) and (d[:game_code] == 'GS3') }
+def list_login_entries(entry_data)
+  handle_error("Fatal: entry_data was not loaded correctly. Got #{entry_data.class} instead of Array.") unless entry_data.is_a?(Array)
+
+  if entry_data.empty?
+    echo "No saved character entries found."
+    return
+  end
+
+  # Calculate column widths
+  account_width = ([7] + entry_data.map { |e| e[:user_id].to_s.length }).max
+  char_width = ([9] + entry_data.map { |e| e[:char_name].to_s.length }).max
+  instance_width = ([8] + entry_data.map { |e| e[:game_code].to_s.length }).max
+  frontend_width = ([8] + entry_data.map { |e| e[:frontend].to_s.length }).max
+
+  # Print header
+  echo "Saved character entries:"
+  echo "#{'-' * (account_width + char_width + instance_width + frontend_width + 13)}"
+  echo "| #{'Account'.ljust(account_width)} | #{'Character'.ljust(char_width)} | #{'Instance'.ljust(instance_width)} | #{'Frontend'.ljust(frontend_width)} |"
+  echo "#{'-' * (account_width + char_width + instance_width + frontend_width + 13)}"
+
+  # Print entries
+  entry_data.each_with_index do |entry, i|
+    account = entry[:user_id].to_s
+    character = entry[:char_name].to_s
+    instance = entry[:game_code].to_s
+    frontend = entry[:frontend].to_s
+    
+    echo "| #{account.ljust(account_width)} | #{character.ljust(char_width)} | #{instance.ljust(instance_width)} | #{frontend.ljust(frontend_width)} |"
+  end
+  
+  echo "#{'-' * (account_width + char_width + instance_width + frontend_width + 13)}"
+  echo "Total: #{entry_data.length} entries"
 end
 
-unless data
-  echo 'Error: No saved account information found.'
-  echo 'Please use the add function to add your character\'s account information.'
-  echo 'Use ;elogin help for more information.'
-  exit
+def delete_login_entry(entry_data, char_name:, game_code:, frontend: nil)
+  matching_entries = entry_data.select do |entry|
+    entry[:char_name].casecmp?(char_name) && entry[:game_code].to_s.casecmp?(game_code.to_s)
+  end
+
+  if matching_entries.empty?
+    handle_error("Delete failed. No matching entry found for #{char_name} (#{game_code}).", should_exit: false)
+    return false
+  end
+
+  if matching_entries.size > 1 && (frontend.nil? || frontend == :__unset)
+    handle_error("Delete failed. Multiple entries exist for #{char_name} (#{game_code}). Specify frontend to delete a precise record.", should_exit: false)
+    return false
+  end
+
+  entry_data.reject! do |entry|
+    entry[:char_name].casecmp?(char_name) &&
+      entry[:game_code].to_s.casecmp?(game_code.to_s) &&
+      (frontend.nil? || frontend == :__unset || entry[:frontend].to_s.casecmp?(frontend.to_s))
+  end
+
+  save_entry_data(entry_data)
+  log_operation("Deleted login entry for #{char_name} (#{game_code})")
+  echo "Deleted entry and saved #{login_backend_version.to_s.upcase}."
+  true
 end
 
-ruby = RbConfig::CONFIG['bindir'] + '/' + (RbConfig::CONFIG['RUBYW_INSTALL_NAME'].empty? ? RbConfig::CONFIG['RUBY_INSTALL_NAME'] : RbConfig::CONFIG['RUBYW_INSTALL_NAME']) + RbConfig::CONFIG['EXEEXT']
+def show_usage
+  echo "Usage:"
+  echo "  ;elogin set realm <prime|platinum|shattered|test>"
+  echo "  ;elogin <char> [script1,script2,...]"
+  echo "  ;elogin add <char> <user_id> <password>"
+  echo "  ;elogin modify <char> <user_id> <password>"
+  echo "  ;elogin delete <char> <game_code>"
+  echo "  ;elogin list"
+end
 
-if File.exist?(ruby)
-  case realm
-  when "shattered"
-    instance = "--gemstone --shattered"
-  when "platinum"
-    instance = "--gemstone --platinum"
-  when "test"
-    instance = "--gemstone --test"
+def parse_arguments(args)
+  # Clean redundant arguments from Lich command processing
+  args.shift if args.size >= 2 && args[0].is_a?(String) && args[1].is_a?(String) && args[0] == args[1..].join(' ')
+  
+  return { command: :help } if args.empty? || args[0] =~ /^help$/i
+  
+  case args[0].to_s.downcase
+  when 'set'
+    if args[1] =~ /^realm$/i && args[2]
+      { command: :set_realm, realm: args[2].to_s.downcase }
+    else
+      { command: :help }
+    end
+  when 'add'
+    if args.length >= 4
+      { command: :add_entry, char_name: args[1].capitalize, user_id: args[2].downcase, password: args[3] }
+    else
+      { command: :help }
+    end
+  when 'modify'
+    if args.length >= 4
+      { command: :modify_entry, char_name: args[1].capitalize, user_id: args[2].downcase, password: args[3] }
+    else
+      { command: :help }
+    end
+  when 'list'
+    { command: :list_entries }
+  when 'delete'
+    if args.length >= 3
+      { command: :delete_entry, char_name: args[1], game_code: args[2] }
+    else
+      { command: :help }
+    end
   else
-    instance = "--gemstone"
+    # Login command - extract character name, instance flag, and scripts
+    char_name = args[0]&.capitalize
+    
+    # Extract instance flag (--GST, --DR, --GSF, etc.)
+    instance_flag = :__unset
+    args.each do |arg|
+      if arg.start_with?('--')
+        flag = arg.sub('--', '').upcase
+        if Lich::Util::LoginHelpers::VALID_GAME_CODES.include?(flag)
+          instance_flag = flag
+          break
+        end
+      end
+    end
+    
+    # Remove instance flag from args and extract scripts
+    args_without_flag = args.reject { |arg| "--#{instance_flag}" == arg }
+    scripts = args_without_flag[1]&.split(',')&.map(&:strip) || []
+    
+    { command: :login, char_name: char_name, instance_flag: instance_flag, scripts: scripts }
   end
-  spawn_string = "\"#{ruby}\" \"#{File.join(LICH_DIR, 'lich.rbw')}\" #{instance} --login #{char_name}"
-  spawn_string += " --start-scripts=#{start_script}" if start_script
-  echo spawn_string
-  Thread.new {
-    Process.spawn(spawn_string)
-  }
-else
-  echo "Error: failed to find rubyw.exe"
 end
+
+# ============================================================================
+# MAIN EXECUTION
+# ============================================================================
+
+# Setup environment
+ensure_login_helpers_loaded(ENV['LICH_MODE'] || 'production')
+
+# Load backend-specific modules
+case login_backend_version
+when :yaml
+  require File.join(LIB_DIR, 'common', 'gui', 'yaml_state')
+end
+
+# Parse arguments
+parsed = parse_arguments(Script.current.vars.dup)
+
+# Execute command
+case parsed[:command]
+when :help
+  show_usage
+
+when :set_realm
+  valid_realms = %w[prime platinum shattered test]
+  unless valid_realms.include?(parsed[:realm])
+    handle_error("Invalid realm. Use: prime, platinum, shattered, or test.")
+  end
+  
+  CharSettings['realm'] = parsed[:realm]
+  log_operation("Set realm to #{parsed[:realm]}")
+  echo "Realm set to #{parsed[:realm]}."
+
+when :add_entry
+  entry_data = load_entry_data
+  add_login_entry(entry_data, 
+    char_name: parsed[:char_name], 
+    user_id: parsed[:user_id], 
+    password: parsed[:password]
+  )
+
+when :modify_entry
+  entry_data = load_entry_data
+  modify_login_entry(entry_data,
+    char_name: parsed[:char_name],
+    user_id: parsed[:user_id],
+    password: parsed[:password]
+  )
+
+when :list_entries
+  entry_data = load_entry_data
+  list_login_entries(entry_data)
+
+when :delete_entry
+  entry_data = load_entry_data
+  delete_login_entry(entry_data, 
+    char_name: parsed[:char_name], 
+    game_code: parsed[:game_code]
+  )
+
+when :login
+  # Validate realm is set
+  realm = CharSettings['realm']
+  handle_error("No realm set. Use ;elogin set realm <prime|platinum|shattered|test>") unless realm
+  
+  # Load entry data
+  entry_data = load_entry_data
+  
+  # Determine game code
+  game_code = if parsed[:instance_flag] == :__unset
+                Lich::Util::LoginHelpers.realm_to_game_code(realm)
+              else
+                parsed[:instance_flag]
+              end
+  
+  # Find character
+  char_records = Lich::Util::LoginHelpers.find_character_by_name_and_game(
+    entry_data, parsed[:char_name], game_code
+  )
+  
+  char_entry = Lich::Util::LoginHelpers.select_best_fit(
+    char_data_sets: char_records,
+    requested_character: parsed[:char_name],
+    requested_instance: game_code.to_s
+  )
+  
+  handle_error("No matching entry found for #{parsed[:char_name]} in realm #{realm}.") unless char_entry
+  
+  # Determine instance override
+  realm_game_code = Lich::Util::LoginHelpers.realm_to_game_code(realm)
+  instance_override = (char_entry[:game_code] == realm_game_code) ? char_entry[:game_code] : char_entry[:_requested_game_code]
+  
+  # Spawn login
+  Lich::Util::LoginHelpers.spawn_login(char_entry, 
+    instance_override: instance_override, 
+    startup_scripts: parsed[:scripts]
+  )
+end
+

From 4f08a6c640673662eccd4428d6ab84ca4b6d4de3 Mon Sep 17 00:00:00 2001
From: OSXLich-Doug <doug@play.net>
Date: Tue, 17 Jun 2025 20:53:10 -0500
Subject: [PATCH 2/5] Update scripts/elogin.lic

ellipsis recommend

Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com>
---
 scripts/elogin.lic | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/elogin.lic b/scripts/elogin.lic
index 08002347e..b4bc49850 100644
--- a/scripts/elogin.lic
+++ b/scripts/elogin.lic
@@ -201,7 +201,7 @@ def add_login_entry(entry_data, char_name:, user_id:, password:, game_code: nil,
                 else 'GS3'
                 end
 
-  existing = entry_data.find { |d| d[:char_name] == char_name && d[:game_code] == game_code }
+  existing = entry_data.find { |d| d[:char_name].casecmp?(char_name) && d[:game_code] == game_code }
   if existing
     handle_error("Error: Add failed. Character already exists for #{char_name} (#{game_code}). Use `modify` to update or `delete` to remove existing entry.")
   end

From 40475d502fc4bddd6d099aabb10484d34fa50cfd Mon Sep 17 00:00:00 2001
From: OSXLich-Doug <doug@play.net>
Date: Tue, 17 Jun 2025 21:02:34 -0500
Subject: [PATCH 3/5] Update elogin.lic - rubocop findings

---
 scripts/elogin.lic | 148 +++++++++++++++++++++++----------------------
 1 file changed, 76 insertions(+), 72 deletions(-)

diff --git a/scripts/elogin.lic b/scripts/elogin.lic
index b4bc49850..79663ce5c 100644
--- a/scripts/elogin.lic
+++ b/scripts/elogin.lic
@@ -1,7 +1,7 @@
 =begin
   e_elogin.lic – Character launcher for Lich 5+
   Uses fallback-aware LoginHelpers to select best character entry and spawn login.
-  
+
   Usage:
     ;elogin help                       # Show usage
     ;elogin set realm <prime|platinum|shattered|test>  # Set game realm
@@ -60,22 +60,22 @@ def load_yaml_entries
   yaml_path = Lich::Common::GUI::YamlState.yaml_file_path(DATA_DIR)
   debug_log("Looking for YAML file at: #{yaml_path}")
   debug_log("YAML file exists: #{File.exist?(yaml_path)}")
-  
+
   handle_error("Error: no saved entries YAML file found at #{yaml_path}") unless File.exist?(yaml_path)
-  
+
   begin
     raw_yaml = YAML.load_file(yaml_path)
     debug_log("Raw YAML loaded: #{raw_yaml.class} with keys: #{raw_yaml.keys if raw_yaml.respond_to?(:keys)}")
     debug_log("Raw YAML accounts: #{raw_yaml['accounts']}")
-    
+
     # Skip symbolize_keys - it's corrupting the data
     # symbolized_yaml = Lich::Util::LoginHelpers.symbolize_keys(raw_yaml)
     # debug_log("Symbolized YAML: #{symbolized_yaml.class}")
     # debug_log("Symbolized YAML accounts: #{symbolized_yaml[:accounts]}")
-    
+
     legacy_format = Lich::Common::GUI::YamlState.convert_yaml_to_legacy_format(raw_yaml)
     debug_log("Legacy format result: #{legacy_format.class} with #{legacy_format.length} entries")
-    
+
     legacy_format
   rescue => e
     debug_log("Error in YAML loading: #{e.class} - #{e.message}")
@@ -86,7 +86,7 @@ end
 def load_dat_entries
   entry_file = File.join(DATA_DIR, 'entry.dat')
   handle_error("Error: entry.dat not found. Set up a character via the Lich front-end or wait for YAML support.") unless File.exist?(entry_file)
-  
+
   begin
     raw = File.read(entry_file)
     decoded = raw.unpack1('m')
@@ -102,7 +102,7 @@ def save_entry_data(entry_data)
   entry_data.each_with_index do |entry, i|
     debug_log("Entry #{i}: #{entry[:char_name]} (#{entry[:game_code]})")
   end
-  
+
   case login_backend_version
   when :yaml
     # For YAML, save_entries expects Array in legacy format and handles conversion internally
@@ -122,7 +122,7 @@ end
 
 def resolve_login_helpers_paths(mode = 'production')
   handle_error("Unsupported Lich version: #{LICH_VERSION}") unless lich_version_at_least?(5, 6, 2)
-  
+
   case mode
   when "production"
     remote_repo = "https://raw.githubusercontent.com/elanthia-online/lich-5/master/lib"
@@ -131,9 +131,9 @@ def resolve_login_helpers_paths(mode = 'production')
   when "alpha"
     local_test_base = ENV['LICH_DEV']
     handle_error("LICH_DEV environment variable not set for alpha mode") unless local_test_base && !local_test_base.strip.empty?
-    
+
     local_test_base = File.expand_path(File.join(local_test_base, "lib"))
-    
+
     if lich_version_at_least?(5, 11, 0)
       source_path = File.join(local_test_base, 'util', 'login_helpers.rb')
       local_path = File.join(LIB_DIR, 'util', 'login_helpers.rb')
@@ -143,7 +143,7 @@ def resolve_login_helpers_paths(mode = 'production')
       local_path = File.join(LIB_DIR, 'login_helpers.rb')
       require_path = File.join(LIB_DIR, 'login_helpers')
     end
-    
+
     return { local_path: local_path, require_path: require_path, source_path: source_path, remote_url: nil }
   else
     handle_error("Unknown mode: #{mode.inspect}")
@@ -163,17 +163,26 @@ end
 
 def ensure_login_helpers_loaded(mode = 'production')
   paths = resolve_login_helpers_paths(mode)
-  
+
   unless File.exist?(paths[:local_path])
     if paths[:source_path] && File.exist?(paths[:source_path])
       FileUtils.mkdir_p(File.dirname(paths[:local_path]))
       FileUtils.cp(paths[:source_path], paths[:local_path])
     elsif paths[:remote_url]
       begin
-        require 'open-uri'
-        content = URI.open(paths[:remote_url], &:read)
-        FileUtils.mkdir_p(File.dirname(paths[:local_path]))
-        File.write(paths[:local_path], content)
+        require 'net/http'
+        require 'uri'
+
+        uri = URI(paths[:remote_url])
+        response = Net::HTTP.get_response(uri)
+
+        if response.code == '200'
+          content = response.body
+          FileUtils.mkdir_p(File.dirname(paths[:local_path]))
+          File.write(paths[:local_path], content)
+        else
+          handle_error("Failed to download login_helpers.rb: HTTP #{response.code}")
+        end
       rescue => e
         handle_error("Failed to download login_helpers.rb from #{paths[:remote_url]}: #{e.message}")
       end
@@ -201,21 +210,21 @@ def add_login_entry(entry_data, char_name:, user_id:, password:, game_code: nil,
                 else 'GS3'
                 end
 
-  existing = entry_data.find { |d| d[:char_name].casecmp?(char_name) && d[:game_code] == game_code }
+  existing = entry_data.find { |d| d[:char_name] == char_name && d[:game_code] == game_code }
   if existing
     handle_error("Error: Add failed. Character already exists for #{char_name} (#{game_code}). Use `modify` to update or `delete` to remove existing entry.")
   end
 
   # Use exact structure from original legacy code
-  h = { 
-    :char_name => char_name, 
-    :game_code => game_code, 
-    :game_name => game_name, 
-    :user_id => user_id.downcase, 
-    :password => password, 
-    :frontend => frontend, 
-    :custom_launch => custom_launch, 
-    :custom_launch_dir => custom_launch_dir 
+  h = {
+    :char_name         => char_name,
+    :game_code         => game_code,
+    :game_name         => game_name,
+    :user_id           => user_id.downcase,
+    :password          => password,
+    :frontend          => frontend,
+    :custom_launch     => custom_launch,
+    :custom_launch_dir => custom_launch_dir
   }
   entry_data.push(h)
 
@@ -231,7 +240,7 @@ def modify_login_entry(entry_data, char_name:, user_id:, password:)
 
   # Find existing entry by character name AND account (user_id)
   existing = entry_data.find { |d| d[:char_name].casecmp?(char_name) && d[:user_id].casecmp?(user_id) }
-  
+
   unless existing
     echo "Modify failed. No entry found for character: #{char_name} with account: #{user_id}"
     echo "Existing characters:"
@@ -243,17 +252,17 @@ def modify_login_entry(entry_data, char_name:, user_id:, password:)
 
   # Remove the old entry
   entry_data.reject! { |d| d[:char_name].casecmp?(char_name) && d[:user_id].casecmp?(user_id) }
-  
+
   # Create new entry with updated password but preserve other fields
-  h = { 
-    :char_name => existing[:char_name], 
-    :game_code => existing[:game_code], 
-    :game_name => existing[:game_name], 
-    :user_id => user_id.downcase, 
-    :password => password, 
-    :frontend => existing[:frontend], 
-    :custom_launch => existing[:custom_launch], 
-    :custom_launch_dir => existing[:custom_launch_dir] 
+  h = {
+    :char_name         => existing[:char_name],
+    :game_code         => existing[:game_code],
+    :game_name         => existing[:game_name],
+    :user_id           => user_id.downcase,
+    :password          => password,
+    :frontend          => existing[:frontend],
+    :custom_launch     => existing[:custom_launch],
+    :custom_launch_dir => existing[:custom_launch_dir]
   }
   entry_data.push(h)
 
@@ -283,15 +292,15 @@ def list_login_entries(entry_data)
   echo "#{'-' * (account_width + char_width + instance_width + frontend_width + 13)}"
 
   # Print entries
-  entry_data.each_with_index do |entry, i|
+  entry_data.each_with_index do |entry, _i|
     account = entry[:user_id].to_s
     character = entry[:char_name].to_s
     instance = entry[:game_code].to_s
     frontend = entry[:frontend].to_s
-    
+
     echo "| #{account.ljust(account_width)} | #{character.ljust(char_width)} | #{instance.ljust(instance_width)} | #{frontend.ljust(frontend_width)} |"
   end
-  
+
   echo "#{'-' * (account_width + char_width + instance_width + frontend_width + 13)}"
   echo "Total: #{entry_data.length} entries"
 end
@@ -336,9 +345,9 @@ end
 def parse_arguments(args)
   # Clean redundant arguments from Lich command processing
   args.shift if args.size >= 2 && args[0].is_a?(String) && args[1].is_a?(String) && args[0] == args[1..].join(' ')
-  
+
   return { command: :help } if args.empty? || args[0] =~ /^help$/i
-  
+
   case args[0].to_s.downcase
   when 'set'
     if args[1] =~ /^realm$/i && args[2]
@@ -369,7 +378,7 @@ def parse_arguments(args)
   else
     # Login command - extract character name, instance flag, and scripts
     char_name = args[0]&.capitalize
-    
+
     # Extract instance flag (--GST, --DR, --GSF, etc.)
     instance_flag = :__unset
     args.each do |arg|
@@ -381,11 +390,11 @@ def parse_arguments(args)
         end
       end
     end
-    
+
     # Remove instance flag from args and extract scripts
     args_without_flag = args.reject { |arg| "--#{instance_flag}" == arg }
     scripts = args_without_flag[1]&.split(',')&.map(&:strip) || []
-    
+
     { command: :login, char_name: char_name, instance_flag: instance_flag, scripts: scripts }
   end
 end
@@ -416,26 +425,24 @@ when :set_realm
   unless valid_realms.include?(parsed[:realm])
     handle_error("Invalid realm. Use: prime, platinum, shattered, or test.")
   end
-  
+
   CharSettings['realm'] = parsed[:realm]
   log_operation("Set realm to #{parsed[:realm]}")
   echo "Realm set to #{parsed[:realm]}."
 
 when :add_entry
   entry_data = load_entry_data
-  add_login_entry(entry_data, 
-    char_name: parsed[:char_name], 
-    user_id: parsed[:user_id], 
-    password: parsed[:password]
-  )
+  add_login_entry(entry_data,
+                  char_name: parsed[:char_name],
+                  user_id: parsed[:user_id],
+                  password: parsed[:password])
 
 when :modify_entry
   entry_data = load_entry_data
   modify_login_entry(entry_data,
-    char_name: parsed[:char_name],
-    user_id: parsed[:user_id],
-    password: parsed[:password]
-  )
+                     char_name: parsed[:char_name],
+                     user_id: parsed[:user_id],
+                     password: parsed[:password])
 
 when :list_entries
   entry_data = load_entry_data
@@ -443,47 +450,44 @@ when :list_entries
 
 when :delete_entry
   entry_data = load_entry_data
-  delete_login_entry(entry_data, 
-    char_name: parsed[:char_name], 
-    game_code: parsed[:game_code]
-  )
+  delete_login_entry(entry_data,
+                     char_name: parsed[:char_name],
+                     game_code: parsed[:game_code])
 
 when :login
   # Validate realm is set
   realm = CharSettings['realm']
   handle_error("No realm set. Use ;elogin set realm <prime|platinum|shattered|test>") unless realm
-  
+
   # Load entry data
   entry_data = load_entry_data
-  
+
   # Determine game code
   game_code = if parsed[:instance_flag] == :__unset
                 Lich::Util::LoginHelpers.realm_to_game_code(realm)
               else
                 parsed[:instance_flag]
               end
-  
+
   # Find character
   char_records = Lich::Util::LoginHelpers.find_character_by_name_and_game(
     entry_data, parsed[:char_name], game_code
   )
-  
+
   char_entry = Lich::Util::LoginHelpers.select_best_fit(
     char_data_sets: char_records,
     requested_character: parsed[:char_name],
     requested_instance: game_code.to_s
   )
-  
+
   handle_error("No matching entry found for #{parsed[:char_name]} in realm #{realm}.") unless char_entry
-  
+
   # Determine instance override
   realm_game_code = Lich::Util::LoginHelpers.realm_to_game_code(realm)
   instance_override = (char_entry[:game_code] == realm_game_code) ? char_entry[:game_code] : char_entry[:_requested_game_code]
-  
+
   # Spawn login
-  Lich::Util::LoginHelpers.spawn_login(char_entry, 
-    instance_override: instance_override, 
-    startup_scripts: parsed[:scripts]
-  )
+  Lich::Util::LoginHelpers.spawn_login(char_entry,
+                                       instance_override: instance_override,
+                                       startup_scripts: parsed[:scripts])
 end
-

From 52906c0d1645d6921679dfafa9a5e3d482ef58bd Mon Sep 17 00:00:00 2001
From: OSXLich-Doug <doug@play.net>
Date: Tue, 17 Jun 2025 21:05:01 -0500
Subject: [PATCH 4/5] Update elogin.lic -- adding back casecmp edit

---
 scripts/elogin.lic | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/elogin.lic b/scripts/elogin.lic
index 79663ce5c..2b4a6516b 100644
--- a/scripts/elogin.lic
+++ b/scripts/elogin.lic
@@ -210,7 +210,7 @@ def add_login_entry(entry_data, char_name:, user_id:, password:, game_code: nil,
                 else 'GS3'
                 end
 
-  existing = entry_data.find { |d| d[:char_name] == char_name && d[:game_code] == game_code }
+  existing = entry_data.find { |d| d[:char_name].casecmp?(char_name) && d[:game_code] == game_code }
   if existing
     handle_error("Error: Add failed. Character already exists for #{char_name} (#{game_code}). Use `modify` to update or `delete` to remove existing entry.")
   end

From e79cb700818e5a2926a385dbafd56ee05c91bf6b Mon Sep 17 00:00:00 2001
From: OSXLich-Doug <doug@play.net>
Date: Wed, 18 Jun 2025 23:27:34 -0500
Subject: [PATCH 5/5] fix(all): move to Lich::Messaging.msg and clean up
 messaging

---
 scripts/elogin.lic | 77 +++++++++++++++++++++++++++-------------------
 1 file changed, 45 insertions(+), 32 deletions(-)

diff --git a/scripts/elogin.lic b/scripts/elogin.lic
index 2b4a6516b..98dde61f8 100644
--- a/scripts/elogin.lic
+++ b/scripts/elogin.lic
@@ -1,13 +1,45 @@
 =begin
-  e_elogin.lic – Character launcher for Lich 5+
-  Uses fallback-aware LoginHelpers to select best character entry and spawn login.
+    elogin.lic: A script for logging into other characters from within lich.
+
+    Useful for switching characters or logging into characters on other accounts.
 
   Usage:
-    ;elogin help                       # Show usage
-    ;elogin set realm <prime|platinum|shattered|test>  # Set game realm
-    ;elogin <char> [script1,script2]  # Login with optional scripts
-    ;elogin add <char> <user_id> <password>  # Add character entry
-    ;elogin delete <char> <game_code>        # Delete character entry
+    ;elogin help                                        # Show usage
+    ;elogin list                                        # List saved characters
+    ;elogin set realm <prime|platinum|shattered|test>   # Set game realm
+    ;elogin <char> [script1,script2]                    # Login with optional scripts
+    ;elogin add <char> <user_id> <password>             # Add character entry
+    ;elogin delete <char> <game_code>                   # Delete character entry
+    ;elogin modify <char> <account> <password>          # Modify chareacter entry
+
+             author: elanthia-online
+       contributors: Phalen33
+               game: Gemstone
+               tags: login
+           required: Lich > 5.0.1
+            version: 2.0.0
+
+  2.0.0 (2025-06-17)
+    - Adds support for Lich 5.12 and beyond
+  1.2.3 (2024-12-02)
+    - Wrap RUBY & LICH location path in quotes incase of spaces in path
+  1.2.2 (2024-11-24)
+    - Remove references to ;trust script, deprecated
+  1.2.1 (2024-10-10)
+    - Anchor regex comparisons and convert to_s
+  1.2.0 (2024-07-22)
+    - Add support for GSTest instance
+  1.1.3 (2023-11-15)
+    - Change ruby process launching from using system() to Process.spawn()
+  1.1.2 (2023-03-28)
+    - Change from using SAL login method to native character saved entry CLI login method
+  1.1.1 (2023-01-23)
+    - Update for Ruby v3 compatibility
+  1.1.0 (2022-02-01)
+    - Fix for Wrayth login method
+    - Add Lich version check
+  1.0.0 (2015-09-19)
+    - Initial release
 =end
 
 LICH_GEM_REQUIRES = '5.0.1'
@@ -29,8 +61,8 @@ def lich_version_at_least?(major, minor = 0, patch = 0)
 end
 
 def debug_log(message)
-  return unless ENV['ELOGIN_DEBUG'] == 'true'
-  echo "DEBUG: #{message}"
+  return unless Lich.debug_messaging
+  Lich::Messaging.msg('debug', "#{message}")
 end
 
 def handle_error(message, should_exit: true)
@@ -66,12 +98,7 @@ def load_yaml_entries
   begin
     raw_yaml = YAML.load_file(yaml_path)
     debug_log("Raw YAML loaded: #{raw_yaml.class} with keys: #{raw_yaml.keys if raw_yaml.respond_to?(:keys)}")
-    debug_log("Raw YAML accounts: #{raw_yaml['accounts']}")
-
-    # Skip symbolize_keys - it's corrupting the data
-    # symbolized_yaml = Lich::Util::LoginHelpers.symbolize_keys(raw_yaml)
-    # debug_log("Symbolized YAML: #{symbolized_yaml.class}")
-    # debug_log("Symbolized YAML accounts: #{symbolized_yaml[:accounts]}")
+    debug_log("Raw YAML accounts: #{raw_yaml['accounts'].count} records.")
 
     legacy_format = Lich::Common::GUI::YamlState.convert_yaml_to_legacy_format(raw_yaml)
     debug_log("Legacy format result: #{legacy_format.class} with #{legacy_format.length} entries")
@@ -279,29 +306,15 @@ def list_login_entries(entry_data)
     return
   end
 
-  # Calculate column widths
-  account_width = ([7] + entry_data.map { |e| e[:user_id].to_s.length }).max
-  char_width = ([9] + entry_data.map { |e| e[:char_name].to_s.length }).max
-  instance_width = ([8] + entry_data.map { |e| e[:game_code].to_s.length }).max
-  frontend_width = ([8] + entry_data.map { |e| e[:frontend].to_s.length }).max
-
-  # Print header
-  echo "Saved character entries:"
-  echo "#{'-' * (account_width + char_width + instance_width + frontend_width + 13)}"
-  echo "| #{'Account'.ljust(account_width)} | #{'Character'.ljust(char_width)} | #{'Instance'.ljust(instance_width)} | #{'Frontend'.ljust(frontend_width)} |"
-  echo "#{'-' * (account_width + char_width + instance_width + frontend_width + 13)}"
-
-  # Print entries
+  saved_entries = Terminal::Table.new(:headings => ['Account', 'Character', 'Instance', 'Frontend'])
   entry_data.each_with_index do |entry, _i|
     account = entry[:user_id].to_s
     character = entry[:char_name].to_s
     instance = entry[:game_code].to_s
     frontend = entry[:frontend].to_s
-
-    echo "| #{account.ljust(account_width)} | #{character.ljust(char_width)} | #{instance.ljust(instance_width)} | #{frontend.ljust(frontend_width)} |"
+    saved_entries.add_row([account, character, instance, frontend])
   end
-
-  echo "#{'-' * (account_width + char_width + instance_width + frontend_width + 13)}"
+  respond saved_entries
   echo "Total: #{entry_data.length} entries"
 end