easyai 1.7.0 → 2.0.0

data/lib/easyai/base/system_keychain.rb

@@ -1,283 +0,0 @@
-require 'rbconfig'
-require 'fileutils'
-require_relative 'system_info'
-
-module EasyAI
-  module Base
-    module SystemKeychain
-      SERVICE_NAME = "easyai"
-      ACCOUNT_NAME = "config_password"
-      
-      # 跨平台密码存储
-      def self.store_password(password)
-        case SystemInfo.platform
-        when :macos
-          store_password_macos(password)
-        when :windows
-          store_password_windows(password)
-        when :linux
-          store_password_linux(password)
-        else
-          puts "⚠ 当前平台不支持密码自动存储，将在会话中临时保存"
-          false
-        end
-      end
-      
-      # 跨平台密码获取
-      def self.get_stored_password
-        case SystemInfo.platform
-        when :macos
-          get_password_macos
-        when :windows
-          get_password_windows
-        when :linux
-          get_password_linux
-        else
-          nil
-        end
-      end
-      
-      # 跨平台密码删除
-      def self.delete_stored_password
-        case SystemInfo.platform
-        when :macos
-          delete_password_macos
-        when :windows
-          delete_password_windows
-        when :linux
-          delete_password_linux
-        else
-          true
-        end
-      end
-      
-      # 检测操作系统平台（已迁移到 SystemInfo）
-      def self.detect_platform
-        SystemInfo.platform
-      end
-      
-      private
-      
-      # macOS Keychain 密码存储
-      def self.store_password_macos(password)
-        # 检查 security 命令是否可用
-        unless system('which security > /dev/null 2>&1')
-          puts "⚠ macOS Keychain 不可用，将使用文件存储"
-          return store_password_linux(password)
-        end
-
-        # 首先尝试更新现有条目
-        update_cmd = "security add-generic-password -a '#{ACCOUNT_NAME}' -s '#{SERVICE_NAME}' -w '#{password}' -U 2>/dev/null"
-        success = system(update_cmd)
-
-        unless success
-          # 如果更新失败，尝试添加新条目
-          add_cmd = "security add-generic-password -a '#{ACCOUNT_NAME}' -s '#{SERVICE_NAME}' -w '#{password}' 2>/dev/null"
-          success = system(add_cmd)
-        end
-
-        if success
-          puts "✓ 密码已安全存储到 macOS Keychain"
-        else
-          puts "⚠ 无法存储密码到 macOS Keychain，尝试使用文件存储"
-          return store_password_linux(password)
-        end
-
-        success
-      rescue => e
-        puts "⚠ Keychain 存储出错: #{e.message}，将使用文件存储"
-        store_password_linux(password)
-      end
-      
-      # macOS Keychain 密码获取
-      def self.get_password_macos
-        # 检查 security 命令是否可用
-        unless system('which security > /dev/null 2>&1')
-          return get_password_linux
-        end
-
-        cmd = "security find-generic-password -a '#{ACCOUNT_NAME}' -s '#{SERVICE_NAME}' -w 2>/dev/null"
-        password = `#{cmd}`.chomp
-
-        if password.empty? || $?.exitstatus != 0
-          # 如果 Keychain 中没有，尝试从文件读取
-          return get_password_linux
-        end
-
-        password
-      rescue => e
-        get_password_linux
-      end
-      
-      # macOS Keychain 密码删除
-      def self.delete_password_macos
-        success = false
-
-        # 尝试从 Keychain 删除
-        if system('which security > /dev/null 2>&1')
-          cmd = "security delete-generic-password -a '#{ACCOUNT_NAME}' -s '#{SERVICE_NAME}' 2>/dev/null"
-          success = system(cmd)
-
-          if success
-            puts "✓ 已从 macOS Keychain 删除存储的密码"
-          end
-        end
-
-        # 同时尝试删除文件存储
-        delete_password_linux
-
-        success
-      rescue => e
-        delete_password_linux
-      end
-      
-      # Windows 凭据管理器密码存储
-      def self.store_password_windows(password)
-        # 使用 cmdkey 命令存储密码
-        target_name = "#{SERVICE_NAME}_#{ACCOUNT_NAME}"
-        cmd = "cmdkey /add:#{target_name} /user:#{ACCOUNT_NAME} /pass:\"#{password}\""
-
-        success = system(cmd + " >nul 2>&1")
-
-        # 同时保存到文件作为备用
-        keyring_dir = File.expand_path('~/.easyai/.keyring')
-        FileUtils.mkdir_p(keyring_dir) unless Dir.exist?(keyring_dir)
-
-        keyring_file = File.join(keyring_dir, 'windows_credential')
-
-        begin
-          require 'base64'
-          encoded_password = Base64.strict_encode64(password)
-          File.write(keyring_file, encoded_password)
-          # Windows 不支持 Unix 权限模型，但文件默认仅当前用户可访问
-          unless Gem.win_platform?
-            File.chmod(0600, keyring_file) rescue nil
-          end
-        rescue => e
-          # 忽略文件写入错误
-        end
-
-        if success
-          puts "✓ 密码已安全存储到 Windows 凭据管理器"
-        else
-          puts "⚠ 无法存储密码到 Windows 凭据管理器"
-        end
-
-        success
-      rescue => e
-        puts "⚠ Windows 凭据存储出错: #{e.message}"
-        false
-      end
-      
-      # Windows 凭据管理器密码获取
-      def self.get_password_windows
-        target_name = "#{SERVICE_NAME}_#{ACCOUNT_NAME}"
-
-        # 首先检查凭据是否存在
-        check_cmd = "cmdkey /list:#{target_name} 2>nul"
-        check_output = `#{check_cmd}`
-        return nil unless check_output.include?(target_name)
-
-        # 使用备用文件存储方式
-        # 因为 Windows 凭据管理器的密码获取需要特殊权限或 CredentialManager 模块
-        # 我们使用加密文件作为备用方案
-        keyring_file = File.expand_path('~/.easyai/.keyring/windows_credential')
-
-        if File.exist?(keyring_file)
-          begin
-            require 'base64'
-            encoded_password = File.read(keyring_file).chomp
-            Base64.strict_decode64(encoded_password)
-          rescue => e
-            nil
-          end
-        else
-          # 提示用户重新输入密码
-          nil
-        end
-      rescue => e
-        nil
-      end
-      
-      # Windows 凭据管理器密码删除
-      def self.delete_password_windows
-        target_name = "#{SERVICE_NAME}_#{ACCOUNT_NAME}"
-        cmd = "cmdkey /delete:#{target_name}"
-
-        success = system(cmd + " >nul 2>&1")
-
-        # 同时删除备用文件
-        keyring_file = File.expand_path('~/.easyai/.keyring/windows_credential')
-        if File.exist?(keyring_file)
-          File.delete(keyring_file) rescue nil
-        end
-
-        if success
-          puts "✓ 已从 Windows 凭据管理器删除存储的密码"
-        end
-
-        success
-      rescue => e
-        false
-      end
-      
-      # Linux 密码存储（使用文件加密存储作为备用方案）
-      def self.store_password_linux(password)
-        keyring_dir = File.expand_path('~/.easyai/.keyring')
-        FileUtils.mkdir_p(keyring_dir) unless Dir.exist?(keyring_dir)
-        
-        keyring_file = File.join(keyring_dir, 'config_key')
-        
-        begin
-          # 使用简单的 Base64 编码存储（在实际生产中应该使用更安全的方法）
-          require 'base64'
-          encoded_password = Base64.strict_encode64(password)
-          File.write(keyring_file, encoded_password)
-          # 设置文件权限（仅在支持的平台上）
-          if !Gem.win_platform?
-            begin
-              File.chmod(0600, keyring_file)
-            rescue => e
-              # 忽略权限设置错误，某些文件系统可能不支持
-            end
-          end
-          
-          puts "✓ 密码已存储到本地加密文件"
-          true
-        rescue => e
-          puts "⚠ Linux 密码存储出错: #{e.message}"
-          false
-        end
-      end
-      
-      # Linux 密码获取
-      def self.get_password_linux
-        keyring_file = File.expand_path('~/.easyai/.keyring/config_key')
-        return nil unless File.exist?(keyring_file)
-        
-        begin
-          require 'base64'
-          encoded_password = File.read(keyring_file).chomp
-          Base64.strict_decode64(encoded_password)
-        rescue => e
-          nil
-        end
-      end
-      
-      # Linux 密码删除
-      def self.delete_password_linux
-        keyring_file = File.expand_path('~/.easyai/.keyring/config_key')
-        
-        if File.exist?(keyring_file)
-          File.delete(keyring_file)
-          puts "✓ 已删除本地存储的密码"
-          true
-        else
-          true
-        end
-      rescue => e
-        false
-      end
-    end
-  end
-end

data/lib/easyai/command/gpt.rb

@@ -1,259 +0,0 @@
-require 'json'
-require 'uri'
-require 'colored2'
-require_relative '../config/config'
-require_relative '../base/system_info'
-
-module EasyAI
-  class Command
-    class GPT < Command
-      self.summary = '运行 OpenAI CLI'
-      self.description = <<-DESC
-        启动 OpenAI GPT CLI 工具。
-
-        主要功能:
-
-            * 支持远程配置下载
-
-            * 自动配置 API 密钥
-
-            * 支持本地配置文件
-
-            * 透传所有参数
-
-        使用示例:
-
-            $ easyai gpt                         # 启动 OpenAI CLI
-
-            $ easyai gpt ./config.json           # 使用本地配置文件
-
-            $ easyai gpt api chat.completions    # 调用 Chat API
-
-            $ easyai gpt --help                  # 查看 OpenAI 帮助
-
-            $ easyai gpt --verbose               # 显示详细信息
-
-            $ easyai gpt --no-keychain           # 禁用密码存储
-      DESC
-
-      def self.options
-        [
-          ['--no-keychain', '禁用自动密码存储'],
-          ['--verbose', '显示详细信息']
-        ].concat(super)
-      end
-
-      def initialize(argv)
-        @no_keychain = argv.flag?('no-keychain')
-        @verbose_mode = argv.flag?('verbose')
-
-        super
-
-        # 获取剩余参数
-        remaining_args = @argv.remainder!
-
-        # 检查第一个参数是否是配置文件
-        if remaining_args.first && File.exist?(remaining_args.first) && remaining_args.first.end_with?('.json')
-          @config_file = remaining_args.shift
-        end
-
-        # 剩余的参数传递给 openai
-        @gpt_args = remaining_args
-      end
-
-      def validate!
-        super
-        help! '未找到 OpenAI CLI。请安装：pip install openai' unless gpt_available?
-      end
-
-      def run
-        begin
-          # 首先尝试获取配置
-          remote_config = nil
-
-          if @config_file
-            # 使用指定的本地配置文件
-            print_status("📁 使用本地配置", File.basename(@config_file))
-            remote_config = load_local_config(@config_file)
-            print_success("配置加载成功") if remote_config
-          else
-            # 从远程下载配置，传递选项（指定工具类型为 gpt）
-            print_status("🔄 获取远程配置", "默认用户")
-            options = {
-              no_keychain: @no_keychain,
-              verbose: @verbose_mode,
-              tool_type: "gpt"  # 指定使用 gpt 组的配置
-            }
-            remote_config = ConfigManager.download_user_config(nil, options)
-
-            # 处理用户取消授权的情况
-            if remote_config == :user_cancelled
-              print_error("用户取消了授权登录")
-              exit 0
-            end
-
-            print_success("配置加载成功") if remote_config
-          end
-
-          # 如果远程配置获取失败，回退到本地配置
-          if remote_config.nil?
-            print_warning("使用本地配置")
-            remote_config = load_local_yaml_config
-
-            # 如果本地配置也为空，提示用户先进行设置
-            if remote_config.empty?
-              print_error("未找到有效配置")
-              puts "  请先运行: #{'easyai --setup'.yellow}"
-              exit 1
-            end
-          end
-
-          # 构建环境变量
-          env = build_environment(remote_config)
-
-          # 运行 OpenAI CLI
-          print_status("🚀 启动 OpenAI", "openai #{@gpt_args.join(' ')}")
-          exec(env, 'openai', *@gpt_args)
-
-        rescue Interrupt
-          puts "\n已取消"
-          exit 0
-        rescue => e
-          print_error("运行失败: #{e.message}")
-          puts e.backtrace if @verbose_mode
-          exit 1
-        end
-      end
-
-      private
-
-      def gpt_available?
-        # 跨平台命令检测
-        Base::SystemInfo.which_command('openai')
-      end
-
-      def load_local_config(config_file)
-        begin
-          content = File.read(config_file)
-          JSON.parse(content)
-        rescue JSON::ParserError => e
-          print_error("配置文件格式错误: #{e.message}")
-          nil
-        rescue => e
-          print_error("读取配置文件失败: #{e.message}")
-          nil
-        end
-      end
-
-      def load_local_yaml_config
-        config_file = File.expand_path('~/.easyai/config.yml')
-        return {} unless File.exist?(config_file)
-
-        begin
-          require 'yaml'
-          YAML.load_file(config_file) || {}
-        rescue => e
-          print_error("读取本地配置失败: #{e.message}")
-          {}
-        end
-      end
-
-      def build_environment(config)
-        env = ENV.to_h
-
-        # 设置 OpenAI API 密钥
-        if config["env"] && config["env"]["OPENAI_API_KEY"]
-          env["OPENAI_API_KEY"] = config["env"]["OPENAI_API_KEY"]
-
-          # 统一显示方式：不显示完整的 API 密钥
-          print_status("🔑 API 密钥", mask_token(config["env"]["OPENAI_API_KEY"]))
-
-          if @verbose_mode
-            # verbose 模式：显示更多状态信息（但不显示敏感内容）
-            puts "  密钥长度: #{config["env"]["OPENAI_API_KEY"].length} 字符"
-          end
-        end
-
-        # 设置代理（如果配置中有）
-        if config["gpt_proxy"]
-          proxy_urls = []
-
-          if config["gpt_proxy"]["HTTP_PROXY"]
-            env["HTTP_PROXY"] = config["gpt_proxy"]["HTTP_PROXY"]
-            env["http_proxy"] = config["gpt_proxy"]["HTTP_PROXY"]
-            proxy_urls << config["gpt_proxy"]["HTTP_PROXY"]
-          end
-
-          if config["gpt_proxy"]["HTTPS_PROXY"]
-            env["HTTPS_PROXY"] = config["gpt_proxy"]["HTTPS_PROXY"]
-            env["https_proxy"] = config["gpt_proxy"]["HTTPS_PROXY"]
-            proxy_urls << config["gpt_proxy"]["HTTPS_PROXY"] unless proxy_urls.include?(config["gpt_proxy"]["HTTPS_PROXY"])
-          end
-
-          if proxy_urls.any?
-            # 统一显示方式：简化代理显示
-            simplified_proxies = proxy_urls.map { |url| mask_url(url) }
-            print_status("🌐 代理已配置", simplified_proxies.join(', '))
-
-          end
-        end
-
-        env
-      end
-
-      def mask_token(token)
-        return nil unless token
-        return "空令牌" if token.empty?
-
-        if token.length > 10
-          "#{token[0..5]}...#{token[-4..-1]}"
-        else
-          "*" * token.length
-        end
-      end
-
-      def mask_url(url)
-        return url unless url
-
-        begin
-          uri = URI(url)
-
-          # 隐藏IP地址的前两段，显示后两段
-          masked_host = uri.host
-          if uri.host =~ /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/
-            masked_host = "*.*.#{$3}.#{$4}"
-          end
-
-          if uri.password
-            "#{uri.scheme}://***@#{masked_host}:#{uri.port}"
-          else
-            "#{uri.scheme}://#{masked_host}:#{uri.port}"
-          end
-        rescue URI::InvalidURIError
-          url
-        end
-      end
-
-      def print_status(icon_text, detail = nil)
-        if detail
-          icon_width = 5
-          puts sprintf("%-#{icon_width}s %s", icon_text, detail.cyan)
-        else
-          puts icon_text
-        end
-      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