easyai 1.7.0 → 2.0.0

data/lib/easyai/command/utils/export.rb

@@ -1,263 +0,0 @@
-require 'json'
-require 'etc'
-require 'open3'
-require 'fileutils'
-require_relative '../../config/config'
-require_relative '../../auth/authclaude'
-require_relative '../../base/system_info'
-
-module EasyAI
-  class Command
-    class Utils < Command
-      class Export < Utils
-        self.summary = '导出 AI 配置信息'
-        self.description = <<-DESC
-          导出当前系统的 AI 配置信息到 JSON 文件。
-
-          主要功能:
-
-              * 从 ~/.claude.json 读取配置
-
-              * 从 Keychain 读取凭证（macOS）
-
-              * 从环境变量读取令牌
-
-              * 自动生成文件名（使用邮箱地址）
-
-          使用示例:
-
-              $ easyai utils export                      # 自动生成文件名
-
-              $ easyai utils export --output=config.json # 指定输出文件名
-
-              $ easyai utils export --verbose            # 显示详细信息
-        DESC
-
-        def self.options
-          [
-            ['--output=FILE', '指定输出文件名'],
-            ['--verbose', '显示详细信息']
-          ].concat(super)
-        end
-
-        def initialize(argv)
-          @output_file = argv.option('output')
-          @verbose = argv.flag?('verbose')
-          super
-        end
-
-        def run
-          puts "正在导出 AI 配置信息..."
-          puts "" if @verbose
-
-          # 收集配置信息
-          export_config = {}
-
-          # 1. 读取 ~/.claude.json
-          user_claude_file = File.expand_path("~/.claude.json")
-
-          if File.exist?(user_claude_file)
-            print_status("📄 读取配置", user_claude_file) if @verbose
-
-            begin
-              user_config = JSON.parse(File.read(user_claude_file))
-
-              # 排除 projects 字段
-              claude_config = user_config.reject { |key, _| key == "projects" }
-
-              # 添加到导出配置
-              export_config["claude_json"] = claude_config
-
-              print_success("读取 ~/.claude.json 成功") if @verbose
-
-              # 如果未指定输出文件名，尝试从配置中获取邮箱地址
-              if @output_file.nil? && claude_config["oauthAccount"]
-                email = claude_config["oauthAccount"]["emailAddress"]
-                if email && !email.empty?
-                  # 使用邮箱地址作为文件名（替换特殊字符）
-                  safe_filename = email.gsub(/[@.]/, '_')
-                  @output_file = "#{safe_filename}.json"
-                  puts "  使用邮箱生成文件名: #{@output_file}" if @verbose
-                end
-              end
-
-            rescue JSON::ParserError => e
-              print_error("解析 ~/.claude.json 失败: #{e.message}")
-              exit 1
-            rescue => e
-              print_error("读取 ~/.claude.json 失败: #{e.message}")
-              exit 1
-            end
-          else
-            print_warning("未找到 ~/.claude.json 文件")
-          end
-
-          # 2. 从 Keychain 读取凭证（macOS）
-          if Base::SystemInfo.macos?
-            print_status("🔐 读取 Keychain", "Claude Code-credentials") if @verbose
-
-            keychain_data = read_keychain_credentials
-            if keychain_data
-              export_config["key_chain"] = {
-                "service_name" => "Claude Code-credentials",
-                "claudeAiOauth" => keychain_data
-              }
-              print_success("读取 Keychain 凭证成功") if @verbose
-            else
-              print_warning("未找到 Keychain 凭证（可选）") if @verbose
-            end
-          else
-            puts "  ⚠️  非 macOS 系统，跳过 Keychain 读取" if @verbose
-          end
-
-          # 3. 从环境变量读取令牌（始终包含 env 字段）
-          token_value = ENV['CLAUDE_CODE_OAUTH_TOKEN'] || ""
-
-          export_config["env"] = {
-            "CLAUDE_CODE_OAUTH_TOKEN" => token_value
-          }
-
-          if token_value && !token_value.empty?
-            print_status("🔑 读取环境变量", "CLAUDE_CODE_OAUTH_TOKEN") if @verbose
-            print_success("读取环境变量成功") if @verbose
-          else
-            print_warning("CLAUDE_CODE_OAUTH_TOKEN 为空（将导出空值）") if @verbose
-          end
-
-          # 4. 读取代理配置（始终包含 claude_proxy 字段）
-          proxy_config = {}
-
-          # 检查 HTTP_PROXY 相关环境变量
-          http_proxy = ENV['HTTP_PROXY'] || ENV['http_proxy'] || ""
-          proxy_config['HTTP_PROXY'] = http_proxy
-
-          # 检查 HTTPS_PROXY 相关环境变量
-          https_proxy = ENV['HTTPS_PROXY'] || ENV['https_proxy'] || ""
-          proxy_config['HTTPS_PROXY'] = https_proxy
-
-          # 始终添加 claude_proxy 字段
-          export_config["claude_proxy"] = proxy_config
-
-          # 显示状态信息
-          if @verbose
-            has_http = !http_proxy.empty?
-            has_https = !https_proxy.empty?
-
-            if has_http || has_https
-              print_status("🌐 读取代理配置", "环境变量")
-              print_success("读取代理配置成功")
-              puts "    HTTP_PROXY: #{has_http ? mask_url(http_proxy) : '(空)'}"
-              puts "    HTTPS_PROXY: #{has_https ? mask_url(https_proxy) : '(空)'}"
-            else
-              print_warning("代理配置为空（将导出空值）")
-            end
-          end
-
-          # 检查是否收集到任何配置
-          if export_config.empty?
-            print_error("未找到任何配置信息可导出")
-            puts "  请确保已配置 Claude 或运行 'easyai --setup'"
-            exit 1
-          end
-
-          # 设置默认输出文件名
-          @output_file ||= "claude_setting.json"
-
-          # 写入文件
-          puts "" if @verbose
-          print_status("💾 写入文件", @output_file)
-
-          begin
-            # 美化 JSON 输出
-            json_output = JSON.pretty_generate(export_config)
-
-            # 写入文件
-            File.write(@output_file, json_output)
-
-            print_success("配置成功导出到 #{@output_file}")
-
-            # 显示导出内容摘要
-            if @verbose
-              puts "\n导出内容摘要:"
-              puts "  ✓ claude.json 配置" if export_config["claude_json"]
-              puts "  ✓ Keychain 凭证" if export_config["key_chain"]
-              puts "  ✓ 环境变量令牌" if export_config["env"]
-              puts "  ✓ 代理配置" if export_config["claude_proxy"]
-            end
-
-          rescue => e
-            print_error("写入文件失败: #{e.message}")
-            exit 1
-          end
-        end
-
-        private
-
-        def claude_available?
-          system('which claude > /dev/null 2>&1')
-        end
-
-        def read_keychain_credentials
-          return nil unless Base::SystemInfo.macos?
-
-          service_name = "Claude Code-credentials"
-          account_name = Base::SystemInfo.current_user
-
-          # 获取 Keychain 中的密码
-          cmd = [
-            "security",
-            "find-generic-password",
-            "-a", account_name,
-            "-s", service_name,
-            "-w"  # 只输出密码
-          ]
-
-          stdout, stderr, status = Open3.capture3(*cmd)
-
-          if status.success? && !stdout.strip.empty?
-            # 尝试解析 JSON 格式的凭证
-            begin
-              credentials = JSON.parse(stdout.strip)
-              return credentials["claudeAiOauth"]
-            rescue JSON::ParserError
-              # 如果不是 JSON，直接返回字符串
-              return stdout.strip
-            end
-          end
-
-          nil
-        end
-
-        def mask_url(url)
-          # 隐藏代理 URL 中的敏感信息
-          return url unless @verbose
-
-          if url =~ /^(https?:\/\/)([^:]+):([^@]+)@(.+)$/
-            protocol, user, pass, rest = $1, $2, $3, $4
-            masked_pass = '*' * [pass.length, 8].min
-            "#{protocol}#{user}:#{masked_pass}@#{rest}"
-          else
-            url
-          end
-        end
-
-        def print_status(icon_text, detail)
-          icon_width = 5  # 图标部分的固定宽度（包括空格）
-          puts sprintf("%-#{icon_width}s %s", icon_text, detail.cyan)
-        end
-
-        def print_success(message)
-          puts "  ✓ #{message}".green
-        end
-
-        def print_warning(message)
-          puts "  ⚠️  #{message}".yellow
-        end
-
-        def print_error(message)
-          puts "✗ #{message}".red
-        end
-      end
-    end
-  end
-end

data/lib/easyai/config/config.rb

@@ -1,357 +0,0 @@
-require 'json'
-require 'fileutils'
-require_relative '../auth/jpsloginhelper'
-require_relative 'easyai_config'
-
-module EasyAI
-  # ConfigManager 类负责业务配置逻辑和用户认证
-  class ConfigManager
-    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_user_config(user_name = nil, options = {})
-      manager = new(options)
-      manager.download_user_config(user_name)
-    end
-
-    # 主要接口：下载用户配置
-    def download_user_config(user_name = nil)
-      puts "正在加载配置..." if @verbose
-      log_config_info if @verbose
-
-      # 确保配置仓库就绪
-      EasyAIConfig.initialize(verbose: @verbose)
-
-      # 获取 index 配置
-      users = get_index_config
-      return nil unless users
-      return nil if users_empty?(users)
-
-      # 获取用户名
-      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
-
-      # 查找并加载配置
-      config_filename = find_user_config(users, selected_user.strip)
-      return nil unless config_filename
-
-      puts "✓ 正在为 #{selected_user} 加载配置" if @verbose
-      get_user_config_content(config_filename)
-    end
-
-    private
-
-    def log_config_info
-      puts "  工具类型: #{@tool_type || '自动'}" if @tool_type
-      puts "  认证平台: #{@platform || (@platform_flag ? '交互式选择' : '自动选择')}" if @tool_type == "claude"
-    end
-
-    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
-
-    def get_user_config_content(config_filename)
-      # 获取配置文件路径
-      config_path = EasyAIConfig.get_config_path(config_filename, verbose: @verbose)
-      return nil unless config_path
-
-      # 读取配置内容
-      begin
-        config_content = File.read(config_path)
-        config = JSON.parse(config_content)
-
-        # 添加配置文件路径信息（用于判断认证类型）
-        config['_config_path'] = config_filename if config
-
-        # 删除解密后的文件
-        if File.exist?(config_path) && config_path.end_with?('.json')
-          encrypted_path = "#{config_path}.encrypted"
-          # 只有存在对应的加密文件时才删除解密文件
-          if File.exist?(encrypted_path)
-            FileUtils.rm_f(config_path)
-            puts "  已清理临时解密文件: #{File.basename(config_path)}" if @verbose
-          end
-        end
-
-        config
-      rescue JSON::ParserError => e
-        puts "✗ 解析配置文件失败: #{e.message}" if @verbose
-        nil
-      rescue => e
-        puts "✗ 读取配置文件失败: #{e.message}" if @verbose
-        nil
-      end
-    end
-
-    # 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
-
-    # 检查用户列表是否为空
-    def users_empty?(users)
-      return true if users.nil? || users.empty?
-
-      # 处理新的分组格式
-      if users.is_a?(Hash) && (users.key?("claude") || users.key?("gemini"))
-        %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.empty?
-      end
-    end
-
-    # 查找用户配置文件
-    def find_user_config(users, user_input_clean)
-      # 处理新的分组格式
-      if users.is_a?(Hash) && (users.key?("claude") || users.key?("gemini"))
-        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
-        # 兼容旧格式
-        find_legacy_user_config(users, user_input_clean)
-      end
-    end
-
-    def find_tool_user_config(tool_users, user_input_clean)
-      return nil unless tool_users.is_a?(Hash)
-
-      tool_users.each do |name, filename|
-        if name.downcase == user_input_clean.downcase
-          return normalize_config_filename(filename)
-        end
-      end
-      nil
-    end
-
-    def find_any_user_config(users, user_input_clean)
-      %w[claude gemini gpt].each do |group|
-        next unless users[group]
-
-        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
-      end
-      nil
-    end
-
-    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 normalize_config_filename(filename)
-      filename = "#{filename}.json" unless filename.end_with?('.json')
-      filename
-    end
-
-    # 专门处理 Claude 的用户配置查找
-    def find_claude_user_config(claude_config, user_input_clean)
-      auth_priority = ["claude_auth", "aliqwen_auth", "kimi_auth", "deepseek_auth"]
-
-      if @platform
-        # 指定了平台
-        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 find_claude_config_by_platform(claude_config, platform, user_input_clean, auth_priority)
-      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 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
-      end
-
-      if @verbose
-        puts "✗ 用户 '#{user_input_clean}' 未找到任何配置"
-        puts "  已尝试: #{auth_priority.join(', ')}"
-      end
-      nil
-    end
-
-    # 在特定认证类型中查找用户配置
-    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 select_platform_for_user(users, user_input_clean)
-      return nil unless users["claude"].is_a?(Hash)
-
-      claude_config = users["claude"]
-      available_platforms = []
-
-      # 检查用户在哪些平台有配置
-      ["claude_auth", "aliqwen_auth", "kimi_auth", "deepseek_auth"].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 "aliqwen_auth" then "阿里通义千问认证"
-        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
-  end
-end