easyai 1.2.1 → 1.3.0

data/lib/easyai/config/config.rb

@@ -1,663 +1,352 @@
 require 'json'
-require 'tmpdir'
 require 'fileutils'
-require 'open3'
-require_relative '../base/file_crypto'
-require_relative '../base/system_keychain'
-require_relative '../auth/jpslogin'
+require_relative '../auth/jpsloginhelper'
+require_relative 'easyai_config'
 
 module EasyAI
+  # ConfigManager 类负责业务配置逻辑和用户认证
   class ConfigManager
-    REPO_URL = "https://gitee.com/goodtools/EasyAISetting.git"
-    EASYAI_DIR = File.expand_path('~/.easyai')
-    CONFIG_REPO_DIR = File.join(EASYAI_DIR, 'EasyAISetting')
-    
-    # 类变量初始化
-    @@no_keychain = false
-    @@verbose = false
-    @@tool_type = nil
-    
-    # 管理配置仓库：如果存在则更新，不存在则下载
-    def self.manage_config_repo
-      # 确保 ~/.easyai 目录存在
-      FileUtils.mkdir_p(EASYAI_DIR) unless Dir.exist?(EASYAI_DIR)
-      
-      if Dir.exist?(CONFIG_REPO_DIR)
-        update_config_repo
-      else
-        download_config_repo
-      end
-    end
-    
-    # 更新现有的配置仓库
-    def self.update_config_repo
-      begin
-        # 检查是否是有效的 git 仓库
-        unless Dir.exist?(File.join(CONFIG_REPO_DIR, '.git'))
-          FileUtils.rm_rf(CONFIG_REPO_DIR)
-          return download_config_repo
-        end
-        
-        # 切换到仓库目录并拉取更新
-        Dir.chdir(CONFIG_REPO_DIR) do
-          # 重置本地更改
-          reset_success = system('git reset --hard HEAD', out: File::NULL, err: File::NULL)
-          unless reset_success
-            FileUtils.rm_rf(CONFIG_REPO_DIR)
-            return download_config_repo
-          end
-          
-          # 拉取最新更新，捕获错误信息
-          stdout, stderr, status = Open3.capture3('git pull origin master')
-          
-          unless status.success?
-            puts "⚠️  配置更新失败，使用缓存配置" if stderr && !stderr.empty?
-            FileUtils.rm_rf(CONFIG_REPO_DIR)
-            return download_config_repo
-          end
-        end
-        
-        return true
-        
-      rescue => e
-        FileUtils.rm_rf(CONFIG_REPO_DIR) if Dir.exist?(CONFIG_REPO_DIR)
-        return download_config_repo
-      end
+    attr_reader :verbose, :tool_type, :platform
+
+    def initialize(options = {})
+      @verbose = options[:verbose] || false
+      @tool_type = options[:tool_type]
+      @platform = options[:platform]
+      @platform_flag = options[:platform_flag] || false
     end
-    
-    # 下载配置仓库到固定位置
-    def self.download_config_repo
-      puts "正在下载配置仓库到 #{CONFIG_REPO_DIR}..." if @@verbose
-      
-      begin
-        # 克隆仓库到固定位置，捕获错误信息
-        stdout, stderr, status = Open3.capture3("git clone --quiet #{REPO_URL} #{CONFIG_REPO_DIR}")
-        
-        unless status.success?
-          puts "✗ 配置仓库下载失败"
-          puts "  错误信息: #{stderr.chomp}" if stderr && !stderr.empty?
-          puts "  请检查网络连接、git 安装状态"
-          return false
-        end
-        
-        puts "✓ 配置仓库下载成功"
-        return true
-        
-      rescue => e
-        puts "✗ 下载配置仓库失败: #{e.message}"
-        return false
-      end
+
+    # 类方法兼容接口
+    def self.download_user_config(user_name = nil, options = {})
+      manager = new(options)
+      manager.download_user_config(user_name)
     end
-    
-    # 从本地配置仓库加载配置
-    def self.load_from_local_repo(user_name = nil, options = {})
-      # 首先管理配置仓库
-      return nil unless manage_config_repo
-
-      # 设置全局选项
-      @@no_keychain = options[:no_keychain] || false
-      @@verbose = options[:verbose] || false
-      @@tool_type = options[:tool_type] || nil
-
-      puts "正在从本地配置仓库加载配置..." if @@verbose
-      puts "  工具类型: #{@@tool_type || '自动'}" if @@verbose && @@tool_type
-      
-      begin
-        # 检查 index.json 文件，支持加密版本
-        index_file = File.join(CONFIG_REPO_DIR, "index.json")
-        encrypted_index_file = File.join(CONFIG_REPO_DIR, "index.json.encrypted")
-        
-        # 优先尝试加密的 index 文件
-        if File.exist?(encrypted_index_file)
-          users = parse_encrypted_index_file(encrypted_index_file)
-        elsif File.exist?(index_file)
-          users = parse_index_file(index_file)
-        else
-          puts "未找到 index.json 或 index.json.encrypted，使用默认配置"
-          config_file = File.join(CONFIG_REPO_DIR, "claude_setting.json")
-          encrypted_config_file = File.join(CONFIG_REPO_DIR, "claude_setting.json.encrypted")
-          
-          if File.exist?(encrypted_config_file)
-            return load_encrypted_config_file(encrypted_config_file)
-          elsif File.exist?(config_file)
-            return load_config_file(config_file)
-          else
-            puts "✗ 未找到配置文件"
-            return nil
-          end
-        end
-        
-        return nil if users.nil?
 
-        # 检查是否有可用用户（支持新旧格式）
-        if is_users_empty?(users)
-          puts "✗ index.json 中未找到用户"
-          return nil
-        end
-        
-        # 获取用户名：优先使用提供的用户名，否则通过 JPS 登录获取
-        if user_name
-          selected_user = user_name
-        else
-          # 统一使用 JPS 登录获取用户名
-          selected_user = get_username_from_jps(@@verbose)
-
-          # 处理用户取消的情况
-          if selected_user == :user_cancelled
-            puts "✗ 用户取消了授权登录"
-            return :user_cancelled
-          elsif selected_user.nil? || selected_user.strip.empty?
-            puts "✗ JPS 登录失败，无法获取用户名"
-            return nil
-          end
-        end
-        
-        # 查找用户配置文件（传入工具类型）
-        config_filename = find_user_config(users, selected_user.strip, @@tool_type)
-
-        if config_filename.nil?
-          puts "✗ 用户 '#{selected_user}' 未找到"
-          # 不显示可用用户列表，保护配置信息
-          puts "  请联系管理员确认用户权限"
-          return nil
-        end
+    # 主要接口：下载用户配置
+    def download_user_config(user_name = nil)
+      puts "正在加载配置..." if @verbose
+      log_config_info if @verbose
 
-        # 加载配置文件，支持加密版本（find_user_config 已确保包含 .json）
-        config_file = File.join(CONFIG_REPO_DIR, config_filename)
-        encrypted_config_file = File.join(CONFIG_REPO_DIR, "#{config_filename}.encrypted")
-        
-        puts "✓ 正在为 #{selected_user} 加载配置"
-        
-        # 优先尝试加密文件
-        if File.exist?(encrypted_config_file)
-          load_encrypted_config_file(encrypted_config_file)
-        elsif File.exist?(config_file)
-          load_config_file(config_file)
-        else
-          puts "✗ 配置文件未找到: #{config_filename}"
-          return nil
-        end
-        
-      rescue => e
-        puts "✗ 加载本地配置失败: #{e.message}"
-        nil
-      end
-    end
-    
-    def self.download_user_config(user_name = nil, options = {})
-      # 优先尝试使用本地配置仓库
-      config = load_from_local_repo(user_name, options)
+      # 确保配置仓库就绪
+      EasyAIConfig.initialize(verbose: @verbose)
+
+      # 获取 index 配置
+      users = get_index_config
+      return nil unless users
+      return nil if users_empty?(users)
 
-      # 如果用户取消了授权，返回特殊标识
-      if config == :user_cancelled
-        return :user_cancelled
+      # 获取用户名
+      selected_user = user_name || get_username_from_jps
+      return handle_user_result(selected_user) unless selected_user.is_a?(String)
+
+      # 处理平台选择
+      if @platform_flag && @tool_type == "claude"
+        @platform = select_platform_for_user(users, selected_user.strip)
+        return nil unless @platform
       end
 
-      return config if config
+      # 查找并加载配置
+      config_filename = find_user_config(users, selected_user.strip)
+      return nil unless config_filename
 
-      # 如果本地仓库失败，回退到临时下载方式
-      puts "本地配置仓库不可用，使用临时下载..."
-      download_user_config_temp(user_name, options)
+      puts "✓ 正在为 #{selected_user} 加载配置" if @verbose
+      get_user_config_content(config_filename)
     end
-    
-    # 原有的临时下载方式（作为备用方案）
-    def self.download_user_config_temp(user_name = nil, options = {})
-      puts "正在获取配置文件..."
-
-      # 设置全局选项
-      @@no_keychain = options[:no_keychain] || false
-      @@verbose = options[:verbose] || false
-      @@tool_type = options[:tool_type] || nil
-      
-      begin
-        # 创建临时目录
-        temp_dir = Dir.mktmpdir("EasyAISetting")
-        
-        # 克隆仓库
-        clone_cmd = "git clone --depth 1 --quiet #{REPO_URL} #{temp_dir}"
-        success = system(clone_cmd, out: File::NULL, err: File::NULL)
-        
-        unless success
-          puts "✗ 配置文件获取失败"
-          puts "  请检查网络连接、git 安装，或使用本地配置文件"
-          cleanup_temp_dir(temp_dir)
-          return nil
-        end
-        
-        puts "✓ 配置文件获取成功"
-        
-        # 检查 index.json 文件，支持加密版本
-        index_file = File.join(temp_dir, "index.json")
-        encrypted_index_file = File.join(temp_dir, "index.json.encrypted")
-        
-        # 优先尝试加密的 index 文件
-        if File.exist?(encrypted_index_file)
-          users = parse_encrypted_index_file(encrypted_index_file)
-        elsif File.exist?(index_file)
-          users = parse_index_file(index_file)
-        else
-          puts "未找到 index.json 或 index.json.encrypted，使用默认配置"
-          config_file = File.join(temp_dir, "claude_setting.json")
-          encrypted_config_file = File.join(temp_dir, "claude_setting.json.encrypted")
-          
-          if File.exist?(encrypted_config_file)
-            config_content = load_encrypted_config_file(encrypted_config_file)
-          elsif File.exist?(config_file)
-            config_content = load_config_file(config_file)
-          else
-            puts "✗ 未找到配置文件"
-            cleanup_temp_dir(temp_dir)
-            return nil
-          end
-          
-          cleanup_temp_dir(temp_dir)
-          return config_content
-        end
-        
-        return nil if users.nil?
 
-        # 检查是否有可用用户（支持新旧格式）
-        if is_users_empty?(users)
-          puts "✗ index.json 中未找到用户"
-          cleanup_temp_dir(temp_dir)
-          return nil
-        end
-        
-        # 获取用户名：优先使用提供的用户名，否则通过 JPS 登录获取
-        if user_name
-          selected_user = user_name
-        else
-          # 统一使用 JPS 登录获取用户名
-          selected_user = get_username_from_jps(@@verbose)
+    private
 
-          # 处理用户取消的情况
-          if selected_user == :user_cancelled
-            puts "✗ 用户取消了授权登录"
-            cleanup_temp_dir(temp_dir)
-            return nil
-          elsif selected_user.nil? || selected_user.strip.empty?
-            puts "✗ JPS 登录失败，无法获取用户名"
-            cleanup_temp_dir(temp_dir)
-            return nil
-          end
-        end
-        
-        # 查找用户配置文件（传入工具类型）
-        config_filename = find_user_config(users, selected_user.strip, @@tool_type)
-
-        if config_filename.nil?
-          puts "✗ 用户 '#{selected_user}' 未找到"
-          # 不显示可用用户列表，保护配置信息
-          puts "  请联系管理员确认用户权限"
-          cleanup_temp_dir(temp_dir)
-          return nil
-        end
+    def log_config_info
+      puts "  工具类型: #{@tool_type || '自动'}" if @tool_type
+      puts "  认证平台: #{@platform || (@platform_flag ? '交互式选择' : '自动选择')}" if @tool_type == "claude"
+    end
 
-        # 加载配置文件，支持加密版本（find_user_config 已确保包含 .json）
-        config_file = File.join(temp_dir, config_filename)
-        encrypted_config_file = File.join(temp_dir, "#{config_filename}.encrypted")
-        
-        puts "✓ 正在为 #{selected_user} 加载配置"
-        
-        # 优先尝试加密文件
-        if File.exist?(encrypted_config_file)
-          config_content = load_encrypted_config_file(encrypted_config_file)
-        elsif File.exist?(config_file)
-          config_content = load_config_file(config_file)
-        else
-          puts "✗ 配置文件未找到: #{config_filename}"
-          cleanup_temp_dir(temp_dir)
-          return nil
-        end
-        
-        cleanup_temp_dir(temp_dir)
-        config_content
-        
-      rescue => e
-        puts "✗ 配置获取失败: #{e.message}"
-        cleanup_temp_dir(temp_dir) if temp_dir
+    def get_index_config
+      # 尝试获取 index 配置，优先加密版本
+      users = EasyAIConfig.get_config('index', verbose: @verbose)
+      return users if users
+
+      # 回退到默认配置
+      puts "未找到 index.json，使用默认配置" if @verbose
+      EasyAIConfig.get_config('claude_setting', verbose: @verbose)
+    end
+
+    def handle_user_result(result)
+      case result
+      when :user_cancelled
+        puts "✗ 用户取消了授权登录"
+        :user_cancelled
+      when nil
+        puts "✗ JPS 登录失败，无法获取用户名"
         nil
+      else
+        result
       end
     end
-    
-    private
-    
-    def self.cleanup_temp_dir(temp_dir)
-      return unless temp_dir && Dir.exist?(temp_dir)
-      FileUtils.rm_rf(temp_dir)
+
+    def get_user_config_content(config_filename)
+      # 直接使用 get_config 获取配置内容，它会自动处理解密和清理
+      config = EasyAIConfig.get_config(config_filename, verbose: @verbose)
+      return config if config
+
+      puts "✗ 无法加载配置文件: #{config_filename}" if @verbose
+      nil
     end
-    
-    def self.parse_index_file(index_file)
-      begin
-        index_content = File.read(index_file)
-        JSON.parse(index_content)
-      rescue JSON::ParserError => e
-        puts "✗ 解析 index.json 失败: #{e.message}"
-        nil
-      rescue => e
-        puts "✗ 读取 index.json 失败: #{e.message}"
+
+    # JPS 登录获取用户名
+    def get_username_from_jps
+      jps_login = Auth::JPSLoginHelper.new(verbose: @verbose)
+      login_result = jps_login.login
+
+      return :user_cancelled if login_result == :user_cancelled
+      return nil unless login_result
+
+      username = jps_login.get_username
+      if username && !username.empty?
+        puts "👤 用户: #{username}" if @verbose
+        username
+      else
         nil
       end
+    rescue => e
+      puts "❌ JPS 登录失败: #{e.message}" if @verbose
+      nil
     end
-    
-    # 通过 JPS 登录获取用户名
-    def self.get_username_from_jps(verbose = false)
-      begin
-        jps_login = Auth::JPSLogin.new(verbose: verbose)
-        login_result = jps_login.login
-
-        # 处理用户主动取消的情况
-        if login_result == :user_cancelled
-          return :user_cancelled
-        end
 
-        if login_result
-          username = jps_login.get_username
-          if username && !username.empty?
-            puts "👤 用户: #{username}"
-            return username
-          end
-        end
-      rescue => e
-        puts "❌ JPS 登录失败: #{e.message}"
-      end
+    # 检查用户列表是否为空
+    def users_empty?(users)
+      return true if users.nil? || users.empty?
 
-      return nil
-    end
-    
-    def self.find_user_config(users, user_input_clean, tool_type = nil)
-      # 处理新的分组格式 {"claude": {...}, "gemini": {...}}
+      # 处理新的分组格式
       if users.is_a?(Hash) && (users.key?("claude") || users.key?("gemini"))
-        # 如果指定了工具类型，只在该组中查找
-        if tool_type && users[tool_type]
-          users[tool_type].each do |name, filename|
-            if name.downcase == user_input_clean.downcase
-              # 确保文件名包含 .json 后缀
-              filename = "#{filename}.json" unless filename.end_with?('.json')
-              return filename
-            end
-          end
-        else
-          # 未指定工具类型时，按优先级查找（claude > gemini > 其他）
-          %w[claude gemini gpt].each do |group|
-            next unless users[group]
-            users[group].each do |name, filename|
-              if name.downcase == user_input_clean.downcase
-                # 确保文件名包含 .json 后缀
-                filename = "#{filename}.json" unless filename.end_with?('.json')
-                return filename
+        %w[claude gemini gpt].each do |group|
+          next unless users[group]
+
+          if group == "claude" && users[group].is_a?(Hash)
+            # Claude 需要检查认证类型
+            users[group].each do |auth_type, auth_users|
+              next unless auth_users.is_a?(Hash)
+              auth_users.each do |name, filename|
+                return false if !filename.nil? && !filename.empty?
               end
             end
+          elsif !users[group].empty?
+            return false
           end
         end
+        true
       else
-        # 兼容旧格式：直接的用户名映射
-        users.each do |name, filename|
-          if name.downcase == user_input_clean.downcase
-            # 确保文件名包含 .json 后缀
-            filename = "#{filename}.json" unless filename.end_with?('.json')
-            return filename
-          end
-        end
+        users.empty?
       end
-
-      nil
     end
 
-    # 获取所有可用的用户名列表
-    def self.get_all_user_names(users)
-      all_names = []
-
+    # 查找用户配置文件
+    def find_user_config(users, user_input_clean)
       # 处理新的分组格式
       if users.is_a?(Hash) && (users.key?("claude") || users.key?("gemini"))
-        %w[claude gemini gpt].each do |group|
-          if users[group] && users[group].is_a?(Hash)
-            group_names = users[group].keys
-            all_names.concat(group_names.map { |name| "#{name} (#{group})" })
-          end
+        if @tool_type == "claude" && users["claude"].is_a?(Hash)
+          find_claude_user_config(users["claude"], user_input_clean)
+        elsif @tool_type && users[@tool_type]
+          find_tool_user_config(users[@tool_type], user_input_clean)
+        else
+          # 未指定工具类型，按优先级查找
+          find_any_user_config(users, user_input_clean)
         end
       else
         # 兼容旧格式
-        all_names = users.keys
+        find_legacy_user_config(users, user_input_clean)
       end
-
-      all_names
     end
 
-    # 获取特定工具的用户名列表
-    def self.get_tool_user_names(users, tool_type)
-      return [] unless tool_type
+    def find_tool_user_config(tool_users, user_input_clean)
+      return nil unless tool_users.is_a?(Hash)
 
-      # 处理新的分组格式
-      if users.is_a?(Hash) && (users.key?("claude") || users.key?("gemini"))
-        # 新格式：返回指定工具组的用户
-        users[tool_type].is_a?(Hash) ? users[tool_type].keys : []
-      else
-        # 旧格式返回所有用户（因为没有工具分组）
-        users.is_a?(Hash) ? users.keys : []
+      tool_users.each do |name, filename|
+        if name.downcase == user_input_clean.downcase
+          return normalize_config_filename(filename)
+        end
       end
+      nil
     end
 
-    # 检查用户列表是否为空
-    def self.is_users_empty?(users)
-      return true if users.nil?
+    def find_any_user_config(users, user_input_clean)
+      %w[claude gemini gpt].each do |group|
+        next unless users[group]
 
-      # 处理新的分组格式
-      if users.is_a?(Hash) && (users.key?("claude") || users.key?("gemini"))
-        # 检查所有组是否都为空
-        %w[claude gemini gpt].each do |group|
-          return false if users[group] && !users[group].empty?
+        if group == "claude" && users[group].is_a?(Hash)
+          config = find_claude_user_config(users[group], user_input_clean)
+          return config if config
+        elsif users[group].is_a?(Hash)
+          config = find_tool_user_config(users[group], user_input_clean)
+          return config if config
         end
-        true
-      else
-        # 兼容旧格式
-        users.empty?
       end
+      nil
     end
-    
-    def self.load_config_file(config_file)
-      begin
-        config_content = File.read(config_file)
-        JSON.parse(config_content)
-      rescue JSON::ParserError => e
-        puts "✗ 解析配置文件失败: #{e.message}"
-        nil
-      rescue => e
-        puts "✗ 读取配置文件失败: #{e.message}"
-        nil
+
+    def find_legacy_user_config(users, user_input_clean)
+      users.each do |name, filename|
+        if name.downcase == user_input_clean.downcase
+          return normalize_config_filename(filename)
+        end
       end
+      nil
     end
-    
-    def self.load_encrypted_config_file(encrypted_config_file)
-      puts "正在解密配置文件..." if @@verbose
-      
-      # 使用新的密码验证机制
-      result = get_and_validate_password(encrypted_config_file, "请输入解密密码: ")
-      return nil unless result
-      
-      begin
-        # 解析 JSON
-        JSON.parse(result[:content])
-      rescue JSON::ParserError => e
-        puts "✗ 解析解密后的配置文件失败: #{e.message}"
-        puts "文件可能已损坏或不是有效的JSON格式"
-        nil
-      end
+
+    def normalize_config_filename(filename)
+      filename = "#{filename}.json" unless filename.end_with?('.json')
+      filename
     end
-    
-    def self.parse_encrypted_index_file(encrypted_index_file)
-      puts "正在解密 index.json..." if @@verbose
-      
-      # 使用新的密码验证机制
-      result = get_and_validate_password(encrypted_index_file, "请输入解密密码: ")
-      return nil unless result
-      
-      begin
-        # 解析 JSON
-        JSON.parse(result[:content])
-      rescue JSON::ParserError => e
-        puts "✗ 解析解密后的 index.json 失败: #{e.message}"
-        puts "文件可能已损坏或不是有效的JSON格式"
-        nil
+
+    # 专门处理 Claude 的用户配置查找
+    def find_claude_user_config(claude_config, user_input_clean)
+      auth_priority = ["claude_auth", "kimi_auth", "deepseek_auth"]
+
+      # Windows 平台处理：从优先级中移除 claude_auth
+      if Gem.win_platform?
+        auth_priority = ["kimi_auth", "deepseek_auth"]
+        puts "  ⚠ Windows 平台跳过 claude_auth，使用其他认证平台" if @verbose
+      end
+
+      if @platform && !@platform.empty?
+        # 指定了平台
+        return find_claude_config_by_platform(claude_config, @platform, user_input_clean, auth_priority)
+      else
+        # 未指定平台，按优先级查找
+        return find_claude_config_auto(claude_config, user_input_clean, auth_priority)
       end
     end
-    
-    # 智能密码获取和验证：包含错误处理和重试机制
-    def self.get_and_validate_password(encrypted_file_path, prompt, max_retries = 3)
-      retries = 0
-      
-      loop do
-        # 获取密码（系统存储或用户输入）
-        password_info = get_decryption_password_basic(prompt, retries > 0)
-        return nil unless password_info
-        
-        # 尝试解密验证密码
-        begin
-          decrypted_content = decrypt_file_content(encrypted_file_path, password_info[:password])
-          
-          # 解密成功，保存密码（如果不是从系统获取且未禁用存储）
-          unless password_info[:from_system] || @@no_keychain
-            if Base::SystemKeychain.store_password(password_info[:password])
-              puts "✓ 密码已安全存储，下次使用将自动获取"
-            end
-          end
-          
-          return { content: decrypted_content, password_info: password_info }
-          
-        rescue => e
-          retries += 1
-          
-          # 分析错误类型并提供针对性提示
-          error_type = analyze_decryption_error(e)
-          
-          # 处理系统密码错误
-          if password_info[:from_system]
-            puts "✗ 系统存储的密码无效"
-            puts "  错误详情：#{e.message}" if error_type[:show_details]
-            puts "  错误原因：#{error_type[:reason]}"
-            puts "正在清除无效的系统存储密码..."
-            Base::SystemKeychain.delete_stored_password
-            puts "✓ 已清除系统存储的无效密码"
-            puts "请重新输入正确的解密密码"
-          else
-            puts "✗ 解密失败"
-            puts "  错误详情：#{e.message}" if error_type[:show_details]
-            puts "  错误原因：#{error_type[:reason]}"
-            puts "  建议：#{error_type[:suggestion]}"
-          end
-          
-          # 检查是否达到最大重试次数
-          if retries >= max_retries
-            puts "\n已达到最大重试次数 (#{max_retries})"
-            puts "可能的解决方案："
-            puts "  1. 确认密码是否正确"
-            puts "  2. 检查文件是否完整下载"
-            puts "  3. 联系管理员确认密码是否已更改"
-            
-            if ask_user_continue?
-              retries = 0  # 重置重试次数，继续尝试
-              puts "\n继续尝试解密..."
-            else
-              puts "用户选择退出解密"
-              return nil
-            end
-          else
-            remaining = max_retries - retries
-            puts "还可以重试 #{remaining} 次 (#{retries}/#{max_retries})"
-            puts "提示：按 Ctrl+C 可随时退出\n"
-          end
-        end
+
+    def find_claude_config_by_platform(claude_config, platform, user_input_clean, auth_priority)
+      # Windows 平台特殊处理 claude_auth
+      if Gem.win_platform? && platform == "claude_auth"
+        puts "✗ Windows 平台不支持 claude_auth" if @verbose
+        puts "  请选择其他认证平台：kimi_auth 或 deepseek_auth" if @verbose
+        return nil
       end
+
+      unless auth_priority.include?(platform)
+        puts "✗ 认证平台 '#{platform}' 不存在" if @verbose
+        puts "  支持的平台: #{auth_priority.join(', ')}" if @verbose
+        return nil
+      end
+
+      config = find_in_auth_type(claude_config, platform, user_input_clean)
+      if config.nil? && @verbose
+        puts "✗ 用户 '#{user_input_clean}' 在 #{platform} 中未找到配置"
+        puts "  请联系管理员添加配置或尝试其他认证平台"
+      elsif config && @verbose
+        puts "✓ 使用认证平台: #{platform}"
+      end
+      config
     end
-    
-    # 基础密码获取：先从系统获取，失败则提示用户输入
-    def self.get_decryption_password_basic(prompt, is_retry = false)
-      # 如果是重试，或者禁用了密码存储，直接提示用户输入
-      if is_retry || @@no_keychain
-        if @@no_keychain
-          puts "已禁用自动密码存储，请手动输入密码"
+
+    def find_claude_config_auto(claude_config, user_input_clean, auth_priority)
+      auth_priority.each do |auth_type|
+        config = find_in_auth_type(claude_config, auth_type, user_input_clean)
+        if config
+          puts "✓ 自动选择认证平台: #{auth_type}" if @verbose
+          return config
         end
-        password = Base::FileCrypto.get_password(prompt)
-        return password ? { password: password, from_system: false } : nil
       end
-      
-      # 首先尝试从系统获取存储的密码
-      stored_password = Base::SystemKeychain.get_stored_password
-      
-      if stored_password && !stored_password.empty?
-        puts "使用系统存储的密码进行解密..." if @@verbose
-        return { password: stored_password, from_system: true }
+
+      if @verbose
+        puts "✗ 用户 '#{user_input_clean}' 未找到任何配置"
+        puts "  已尝试: #{auth_priority.join(', ')}"
       end
-      
-      # 如果没有存储的密码，提示用户输入
-      password = Base::FileCrypto.get_password(prompt)
-      return password ? { password: password, from_system: false } : nil
+      nil
     end
-    
-    # 分析解密错误类型，提供针对性建议
-    def self.analyze_decryption_error(error)
-      case error.message
-      when /bad decrypt/i, /wrong final block length/i, /invalid padding/i
-        {
-          reason: "密码不正确或文件已损坏",
-          suggestion: "请确认密码是否正确，或检查文件完整性",
-          show_details: false
-        }
-      when /not supported by device/i
-        {
-          reason: "系统不支持此加密算法或文件格式错误", 
-          suggestion: "请检查文件是否为正确的加密文件",
-          show_details: true
-        }
-      when /no such file/i, /cannot open/i
-        {
-          reason: "文件不存在或无法访问",
-          suggestion: "请检查文件路径和权限",
-          show_details: false
-        }
-      when /invalid base64/i
-        {
-          reason: "文件格式错误或已损坏",
-          suggestion: "请重新下载配置文件",
-          show_details: false
-        }
-      else
-        {
-          reason: "未知的解密错误",
-          suggestion: "请尝试重新下载文件或联系技术支持",
-          show_details: true
-        }
+
+    # 在特定认证类型中查找用户配置
+    def find_in_auth_type(claude_config, auth_type, user_input_clean)
+      return nil unless claude_config[auth_type].is_a?(Hash)
+
+      claude_config[auth_type].each do |name, filename|
+        if name.downcase == user_input_clean.downcase && !filename.nil? && !filename.empty?
+          filename = normalize_config_filename(filename)
+          return "claude/#{auth_type}/#{filename}"
+        end
       end
+      nil
     end
-    
-    # 询问用户是否继续尝试
-    def self.ask_user_continue?
-      puts "\n是否继续尝试解密？"
-      puts "  y/yes - 继续尝试"
-      puts "  n/no  - 退出解密 (默认)"
-      print "> "
-      
-      begin
-        response = STDIN.gets&.chomp&.downcase
-        return ['y', 'yes'].include?(response)
-      rescue Interrupt
-        puts "\n\n用户中断操作"
-        return false
-      rescue => e
-        puts "无法读取用户输入: #{e.message}"
-        return false
+
+    # 让用户选择可用的认证平台
+    def select_platform_for_user(users, user_input_clean)
+      return nil unless users["claude"].is_a?(Hash)
+
+      claude_config = users["claude"]
+      available_platforms = []
+
+      # 检查用户在哪些平台有配置
+      platforms_to_check = ["claude_auth", "kimi_auth", "deepseek_auth"]
+
+      # Windows 平台跳过 claude_auth
+      if Gem.win_platform?
+        platforms_to_check = ["kimi_auth", "deepseek_auth"]
+      end
+
+      platforms_to_check.each do |auth_type|
+        if find_in_auth_type(claude_config, auth_type, user_input_clean)
+          available_platforms << auth_type
+        end
+      end
+
+      # 如果没有可用平台
+      if available_platforms.empty?
+        puts "✗ 用户 '#{user_input_clean}' 在任何认证平台中都没有配置"
+        return nil
+      end
+
+      # 如果只有一个平台，直接使用
+      if available_platforms.length == 1
+        selected = available_platforms.first
+        puts "✓ 自动选择唯一可用平台: #{selected}" if @verbose
+        return selected
+      end
+
+      # 多个平台，让用户选择
+      puts "\n🔐 请选择认证平台:"
+      puts "─" * 40
+
+      available_platforms.each_with_index do |platform, index|
+        platform_name = case platform
+        when "claude_auth" then "Claude 官方认证"
+        when "kimi_auth" then "Kimi 认证"
+        when "deepseek_auth" then "Deepseek 认证"
+        else platform
+        end
+        puts "  #{index + 1}. #{platform_name} (#{platform})"
+      end
+
+      puts "─" * 40
+
+      loop do
+        print "请输入选择 (1-#{available_platforms.length}，输入 q 退出): "
+
+        begin
+          choice = STDIN.gets&.chomp
+
+          # 用户选择退出
+          if choice.nil? || choice.downcase == 'q'
+            puts "✗ 用户取消选择"
+            return nil
+          end
+
+          # 验证输入
+          choice_num = choice.to_i
+          if choice_num >= 1 && choice_num <= available_platforms.length
+            selected = available_platforms[choice_num - 1]
+            puts "✓ 已选择: #{selected}" if @verbose
+            return selected
+          else
+            puts "✗ 无效的选择，请输入 1-#{available_platforms.length} 之间的数字"
+          end
+        rescue Interrupt
+          puts "\n\n✗ 用户中断操作"
+          return nil
+        rescue => e
+          puts "✗ 输入错误: #{e.message}"
+          return nil
+        end
       end
-    end
-    
-    def self.decrypt_file_content(encrypted_file_path, password)
-      # 生成密钥
-      key = Base::FileCrypto.generate_key(password)
-      
-      # 读取加密文件内容
-      encrypted_content = File.read(encrypted_file_path)
-      
-      # 解密内容
-      Base::FileCrypto.aes_128_ecb_decrypt(key, encrypted_content)
     end
   end
 end