easyai 1.7.0 → 2.0.0

data/lib/easyai/auth/authclaude.rb

@@ -1,519 +0,0 @@
-require 'json'
-require 'etc'
-require 'open3'
-require 'fileutils'
-require_relative '../base/system_info'
-
-module EasyAI
-  module Auth
-    class AuthClaude
-      # 常量定义
-      SERVICE_NAME = "Claude Code-credentials"
-      TOKEN_KEY = "CLAUDE_CODE_OAUTH_TOKEN"
-      ALT_TOKEN_KEY = "ANTHROPIC_AUTH_TOKEN"
-      CLAUDE_JSON_PATH = File.expand_path("~/.claude.json")
-
-      def self.configure(config, user_name = nil)
-        return false unless config
-
-        # 第一步：清理系统环境，确保干净的运行环境
-        clean_system_environment
-
-        # 检查认证配置优先级
-        keychain_exists = macos? && config["key_chain"] && config["key_chain"]["claudeAiOauth"] && config["key_chain"]["service_name"]
-        # 检查两种可能的令牌键
-        env_token_exists = config["env"] && (config["env"][TOKEN_KEY] || config["env"][ALT_TOKEN_KEY])
-        
-        # 如果使用 Keychain，需要将令牌从 Keychain 读取到配置中
-        if keychain_exists
-          token_from_keychain = get_token_from_keychain(config["key_chain"]["service_name"])
-          if token_from_keychain
-            config["env"] ||= {}
-            config["env"][TOKEN_KEY] = token_from_keychain
-          end
-        end
-        
-        # 根据优先级确定认证方法
-        if keychain_exists
-          configure_keychain(config)
-          clean_env_variables
-        elsif env_token_exists
-          verify_token_config(config)
-          clean_keychain if macos?
-        else
-          # 先检查环境变量中是否已有令牌
-          token = check_env_tokens
-
-          if token.nil? || token.empty?
-            # 环境变量中没有，才提示用户输入
-            token = prompt_for_token
-            return false if token.nil? || token.empty?
-          else
-            log_verbose("  ✓ 使用环境变量中的令牌")
-          end
-
-          # 将令牌添加到配置中进行处理
-          # 如果配置中已经有 ANTHROPIC_AUTH_TOKEN，使用该键；否则使用 CLAUDE_CODE_OAUTH_TOKEN
-          config["env"] ||= {}
-          if config["env"][ALT_TOKEN_KEY]
-            config["env"][ALT_TOKEN_KEY] = token
-          else
-            config["env"][TOKEN_KEY] = token
-          end
-
-          verify_token_config(config)
-          clean_keychain
-        end
-        
-        # 更新 ~/.claude.json 文件
-        update_claude_json(config) if config["claude_json"]
-        
-        # 配置代理设置
-        configure_proxy(config) if config["claude_proxy"]
-        
-        true
-      end
-
-      private
-
-      # 辅助方法
-      def self.macos?
-        Base::SystemInfo.macos?
-      end
-
-      def self.current_user
-        Base::SystemInfo.current_user
-      end
-
-      def self.log_verbose(message)
-        puts message if ENV['EASYAI_DEBUG'] || ENV['EASYAI_VERBOSE']
-      end
-
-      def self.log_debug(message)
-        puts message if ENV['EASYAI_DEBUG']
-      end
-
-      # 通用的 shell 文件处理方法
-      def self.process_shell_files(operation_name)
-        shell_files = get_shell_files
-
-        shell_files.each do |shell_file|
-          next unless File.exist?(shell_file)
-
-          begin
-            content = File.read(shell_file)
-            lines = content.split("\n", -1)
-            lines.pop if lines.last == ""
-
-            original_count = lines.length
-            lines = yield(lines, shell_file)
-            removed_count = original_count - lines.length
-
-            if removed_count > 0
-              File.write(shell_file, lines.join("\n") + "\n")
-              log_verbose("  ✓ 已从 #{File.basename(shell_file)} 中清理 #{removed_count} 行#{operation_name}")
-            end
-          rescue => e
-            log_debug("  ⚠ 处理 #{shell_file} 失败: #{e.message}")
-          end
-        end
-      end
-
-      def self.clean_system_environment
-        log_verbose("🧹 清理系统环境...")
-
-        # 1. 清理 ~/.claude.json 中的 oauthAccount
-        clean_claude_json_oauth
-
-        # 2. 清理 Keychain（仅 macOS）
-        clean_keychain if macos?
-
-        # 3. 清理环境变量中的 token
-        clean_env_variables
-
-        # 4. 清理环境变量中的代理设置
-        clean_proxy_variables
-
-        log_verbose("  ✓ 系统环境清理完成")
-      end
-
-      def self.clean_claude_json_oauth
-        return unless File.exist?(CLAUDE_JSON_PATH)
-
-        begin
-          content = File.read(CLAUDE_JSON_PATH)
-          config = JSON.parse(content)
-
-          # 删除 oauthAccount 字段
-          if config.delete("oauthAccount")
-            # 写回文件
-            File.write(CLAUDE_JSON_PATH, JSON.pretty_generate(config))
-            log_verbose("  ✓ 已清理 ~/.claude.json 中的 oauthAccount")
-          end
-        rescue JSON::ParserError => e
-          log_debug("  ⚠ 解析 ~/.claude.json 失败: #{e.message}")
-        rescue => e
-          log_debug("  ⚠ 清理 ~/.claude.json 失败: #{e.message}")
-        end
-      end
-
-      def self.clean_proxy_variables
-        process_shell_files("代理配置") do |lines, shell_file|
-          remove_all_proxy_config(lines, shell_file)
-        end
-      end
-
-      def self.get_token_from_keychain(service_name)
-        return nil unless macos?
-
-        cmd = [
-          "security",
-          "find-generic-password",
-          "-a", current_user,
-          "-s", service_name,
-          "-w"
-        ]
-        
-        begin
-          stdout, stderr, status = Open3.capture3(*cmd)
-          
-          if status.success? && !stdout.strip.empty?
-            # 解析 JSON 格式的密码
-            credentials = JSON.parse(stdout.strip)
-            return credentials["claudeAiOauth"]
-          end
-        rescue JSON::ParserError, StandardError
-          # 如果不是 JSON 格式，尝试直接返回
-          return stdout.strip if status.success? && !stdout.strip.empty?
-        end
-        
-        nil
-      end
-      
-      def self.configure_keychain(config)
-        credentials = {
-          "claudeAiOauth" => config["key_chain"]["claudeAiOauth"]
-        }
-
-        service_name = config["key_chain"]["service_name"]
-        password = credentials.to_json
-
-        cmd = [
-          "security",
-          "add-generic-password",
-          "-a", current_user,
-          "-s", service_name,
-          "-l", service_name,
-          "-w", password,
-          "-U",
-          "-T", ""
-        ]
-
-        system(*cmd)
-
-        if $?.success?
-          verify_keychain_entry(current_user, service_name)
-        else
-          puts "✗ 保存凭证到 Keychain 失败"
-          return false
-        end
-
-        true
-      end
-      
-      def self.verify_keychain_entry(account_name, service_name)
-        verify_cmd = [
-          "security",
-          "find-generic-password",
-          "-a", account_name,
-          "-s", service_name
-        ]
-        
-        unless system(*verify_cmd, out: File::NULL, err: File::NULL)
-          puts "✗ 无法验证 Keychain 条目"
-        end
-      end
-      
-      def self.verify_token_config(config)
-        # 检查两种可能的令牌键
-        token = config["env"][TOKEN_KEY] || config["env"][ALT_TOKEN_KEY]
-        return false unless token
-
-        # 只验证令牌存在且不为空，不写入任何配置文件
-        if token && !token.strip.empty?
-          # 清理任何现有的环境配置文件中的令牌定义
-          clean_env_variables
-          return true
-        else
-          puts "✗ 令牌配置无效"
-          return false
-        end
-      end
-      
-      def self.update_claude_json(config)
-        begin
-          # 读取现有文件或创建空哈希
-          if File.exist?(CLAUDE_JSON_PATH)
-            user_config = JSON.parse(File.read(CLAUDE_JSON_PATH))
-          else
-            user_config = {}
-          end
-
-          # 合并 claude_json 内容，过滤掉代理相关字段
-          claude_config = config["claude_json"].dup
-          claude_config.delete("claude_proxy")
-          claude_config.delete("HTTP_PROXY")
-          claude_config.delete("HTTPS_PROXY")
-
-          user_config.merge!(claude_config)
-
-          # 写回文件
-          File.write(CLAUDE_JSON_PATH, JSON.pretty_generate(user_config))
-
-        rescue JSON::ParserError => e
-          puts "✗ 解析现有 ~/.claude.json 失败: #{e.message}"
-          false
-        rescue => e
-          puts "✗ 更新 ~/.claude.json 失败: #{e.message}"
-          false
-        end
-      end
-      
-      def self.configure_proxy(config)
-        return unless config["claude_proxy"] && (config["claude_proxy"]["HTTP_PROXY"] || config["claude_proxy"]["HTTPS_PROXY"])
-        
-        http_proxy = config["claude_proxy"]["HTTP_PROXY"]
-        https_proxy = config["claude_proxy"]["HTTPS_PROXY"]
-        
-        shell_files = get_shell_files
-        
-        shell_files.each do |shell_file|
-          next unless File.exist?(shell_file)
-          
-          begin
-            content = File.read(shell_file)
-            lines = content.split("\n", -1)
-            lines.pop if lines.last == ""
-            
-            # 移除所有现有的代理相关配置
-            lines = remove_all_proxy_config(lines, shell_file)
-            
-            # 只添加代理别名/函数，不直接设置环境变量
-            lines = add_proxy_aliases(lines, shell_file, http_proxy, https_proxy)
-            
-            # 写回文件
-            File.write(shell_file, lines.join("\n") + "\n")
-            
-          rescue => e
-            puts "  ✗ 更新 #{shell_file} 失败: #{e.message}"
-          end
-        end
-        
-        # 显示代理配置完成信息
-        puts "✅ 代理别名已配置 | claude_proxy / unclaude_proxy"
-      end
-      
-      # 检查环境变量中的令牌
-      def self.check_env_tokens
-        # 优先使用 CLAUDE_CODE_OAUTH_TOKEN，其次是 ANTHROPIC_AUTH_TOKEN
-        token = ENV[TOKEN_KEY] || ENV[ALT_TOKEN_KEY]
-        token&.strip&.empty? ? nil : token
-      end
-
-      def self.prompt_for_token
-        puts "请输入您的 CLAUDE_CODE_OAUTH_TOKEN："
-        print "> "
-
-        begin
-          # 简化输入处理，直接使用 STDIN
-          STDIN.gets&.chomp
-        rescue => e
-          puts "✗ 无法读取输入: #{e.message}"
-          puts "  请使用本地配置文件或 --user 参数"
-          nil
-        end
-      end
-      
-      def self.clean_env_variables
-        process_shell_files("令牌配置") do |lines, shell_file|
-          patterns = get_token_patterns(shell_file)
-          lines.reject { |line| patterns.any? { |pattern| line.match(pattern) } }
-        end
-      end
-      
-      def self.clean_keychain
-        return unless macos?
-
-        cmd = [
-          "security",
-          "delete-generic-password",
-          "-a", current_user,
-          "-s", SERVICE_NAME
-        ]
-
-        stdout, stderr, status = Open3.capture3(*cmd)
-
-        if status.success?
-          log_verbose("  ✓ 已清理 Keychain 中的 Claude Code 凭证")
-        elsif !stderr.include?("could not be found")
-          log_debug("  ⚠ 清理 Keychain 失败: #{stderr}")
-        end
-      end
-      
-      def self.get_shell_files
-        Base::SystemInfo.shell_config_files
-      end
-      
-      def self.get_token_patterns(shell_file)
-        if shell_file.include?("config.fish")
-          [
-            /^set\s+-gx\s+#{Regexp.escape(TOKEN_KEY)}\s/,
-            /^set\s+-x\s+#{Regexp.escape(TOKEN_KEY)}\s/,
-            /^#set\s+-gx\s+#{Regexp.escape(TOKEN_KEY)}\s/
-          ]
-        else
-          [
-            /^export\s+#{Regexp.escape(TOKEN_KEY)}=/,
-            /^#{Regexp.escape(TOKEN_KEY)}=/,
-            /^#export\s+#{Regexp.escape(TOKEN_KEY)}=/
-          ]
-        end
-      end
-
-      def self.get_export_line(shell_file, token)
-        if shell_file.include?("config.fish")
-          "set -gx #{TOKEN_KEY} \"#{token}\""
-        else
-          "export #{TOKEN_KEY}=\"#{token}\""
-        end
-      end
-      
-      def self.remove_all_proxy_config(lines, shell_file)
-        # 更全面的代理配置清理，包括所有可能的代理设置
-        if shell_file.include?("config.fish")
-          # Fish shell 代理配置清理
-          lines.reject! { |line|
-            # 清理环境变量设置
-            line.match(/^set\s+-[gx]+\s+(HTTP_PROXY|HTTPS_PROXY|http_proxy|https_proxy|ALL_PROXY|all_proxy|NO_PROXY|no_proxy)\s/) ||
-            line.match(/^export\s+(HTTP_PROXY|HTTPS_PROXY|http_proxy|https_proxy|ALL_PROXY|all_proxy|NO_PROXY|no_proxy)=/) ||
-            # 清理别名
-            line.match(/^alias\s+(claude_proxy|unclaude_proxy|proxy|unproxy)=/) ||
-            # 清理函数
-            line.match(/^function\s+(claude_proxy|unclaude_proxy|proxy|unproxy)/)
-          }
-
-          # 移除函数块
-          in_function = false
-          lines = lines.select do |line|
-            if line.match(/^function\s+(claude_proxy|unclaude_proxy|proxy|unproxy)/)
-              in_function = true
-              false
-            elsif in_function && line.strip == "end"
-              in_function = false
-              false
-            elsif in_function
-              false
-            else
-              true
-            end
-          end
-        else
-          # Bash/zsh 代理配置清理
-          lines.reject! { |line|
-            # 清理环境变量设置
-            line.match(/^export\s+(HTTP_PROXY|HTTPS_PROXY|http_proxy|https_proxy|ALL_PROXY|all_proxy|NO_PROXY|no_proxy)=/) ||
-            line.match(/^(HTTP_PROXY|HTTPS_PROXY|http_proxy|https_proxy|ALL_PROXY|all_proxy|NO_PROXY|no_proxy)=/) ||
-            # 清理别名
-            line.match(/^alias\s+(claude_proxy|unclaude_proxy|proxy|unproxy)=/) ||
-            # 清理函数
-            line.match(/^(claude_proxy|unclaude_proxy|proxy|unproxy)\(\)/) ||
-            # 清理函数定义的另一种格式
-            line.match(/^function\s+(claude_proxy|unclaude_proxy|proxy|unproxy)/)
-          }
-
-          # 移除函数块
-          in_function = false
-          function_depth = 0
-          lines = lines.select do |line|
-            if line.match(/^(claude_proxy|unclaude_proxy|proxy|unproxy)\(\)/) ||
-               line.match(/^function\s+(claude_proxy|unclaude_proxy|proxy|unproxy)/)
-              in_function = true
-              function_depth = 0
-              false
-            elsif in_function
-              function_depth += 1 if line.include?("{")
-              if line.include?("}")
-                function_depth -= 1
-                if function_depth <= 0
-                  in_function = false
-                  false
-                else
-                  false
-                end
-              else
-                false
-              end
-            else
-              true
-            end
-          end
-        end
-
-        lines
-      end
-
-      # remove_proxy_config 方法已被 remove_all_proxy_config 替代
-      # remove_all_proxy_config 提供更全面的清理功能，包括 ALL_PROXY 和 NO_PROXY
-
-      def self.add_proxy_aliases(lines, shell_file, http_proxy, https_proxy)
-        if shell_file.include?("config.fish")
-          # Fish shell - 只添加函数，不直接设置环境变量
-          proxy_commands = []
-          proxy_commands << ""
-          proxy_commands << "function claude_proxy"
-          if http_proxy
-            proxy_commands << "    set -gx HTTP_PROXY \"#{http_proxy}\""
-            proxy_commands << "    set -gx http_proxy \"#{http_proxy}\""
-          end
-          if https_proxy
-            proxy_commands << "    set -gx HTTPS_PROXY \"#{https_proxy}\""
-            proxy_commands << "    set -gx https_proxy \"#{https_proxy}\""
-          end
-          proxy_commands << "    echo '代理已启用: HTTP_PROXY=#{http_proxy || 'not set'}, HTTPS_PROXY=#{https_proxy || 'not set'}'"
-          proxy_commands << "end"
-          
-          proxy_commands << ""
-          proxy_commands << "function unclaude_proxy"
-          proxy_commands << "    set -e HTTP_PROXY"
-          proxy_commands << "    set -e http_proxy"
-          proxy_commands << "    set -e HTTPS_PROXY"
-          proxy_commands << "    set -e https_proxy"
-          proxy_commands << "    echo '代理已禁用'"
-          proxy_commands << "end"
-          
-          lines.concat(proxy_commands)
-        else
-          # Bash/zsh - 只添加别名，不直接设置环境变量
-          proxy_exports = []
-          if http_proxy
-            proxy_exports << "export HTTP_PROXY=\"#{http_proxy}\""
-            proxy_exports << "export http_proxy=\"#{http_proxy}\""
-          end
-          if https_proxy
-            proxy_exports << "export HTTPS_PROXY=\"#{https_proxy}\""
-            proxy_exports << "export https_proxy=\"#{https_proxy}\""
-          end
-          
-          if proxy_exports.any?
-            lines << ""
-            lines << "alias claude_proxy='#{proxy_exports.join("; ")}; echo \"代理已启用: HTTP_PROXY=#{http_proxy || 'not set'}, HTTPS_PROXY=#{https_proxy || 'not set'}\"'"
-          end
-          
-          lines << "alias unclaude_proxy='unset HTTP_PROXY http_proxy HTTPS_PROXY https_proxy; echo \"代理已禁用\"'"
-        end
-        
-        lines
-      end
-    end
-  end
-end

data/lib/easyai/auth/jpsloginhelper.rb

@@ -1,98 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'jpsclient'
-require 'fileutils'
-require 'json'
-require_relative '../config/easyai_config'
-
-module EasyAI
-  module Auth
-    class JPSLoginHelper
-      attr_reader :username
-
-      def initialize(options = {})
-        @verbose = options[:verbose] || false
-
-        # 如果传入了配置文件路径，直接使用
-        if options[:config_file]
-          @config_file_path = options[:config_file]
-        else
-          # 通过 EasyAIConfig 获取 jpsclient 配置文件路径
-          # 首先确保配置仓库已初始化
-          EasyAIConfig.initialize(verbose: @verbose)
-
-          # 获取 jpsclient 配置文件路径（会自动解密到临时目录）
-          @config_file_path = EasyAIConfig.get_config_path('jps_client_config', verbose: @verbose)
-        end
-
-        @client = nil
-        @username = nil
-      end
-
-      # 主登录入口 - 兼容原 JPSLogin 接口
-      def login
-        begin
-          # 检查配置文件路径
-          if @config_file_path.nil?
-            puts "✗ 未找到 jpsclient 配置文件"
-            puts "  请确保配置仓库已下载并解密"
-            return false
-          end
-
-          # 检查配置文件是否存在
-          unless File.exist?(@config_file_path)
-            puts "✗ 配置文件不存在: #{@config_file_path}"
-            puts "  请先从配置仓库下载并解密配置文件"
-            return false
-          end
-
-          @client ||= JPSClient::Client.new(config_file: @config_file_path)
-
-          # 执行登录
-          result = @client.do_login(force_login: false)
-
-          if result == :user_cancelled
-            return :user_cancelled
-          end
-
-          if result
-            # 登录成功，获取用户名
-            @username = get_username_from_client
-            return true
-          end
-
-          return false
-        rescue => e
-          puts "✗ JPS 登录失败: #{e.message}" if @verbose
-          return false
-        end
-      end
-
-      # 获取用户名 - 兼容原 JPSLogin 接口
-      def get_username
-        return @username if @username
-
-        # 如果客户端存在且已登录，尝试获取用户名
-        if @client
-          @username = get_username_from_client
-        end
-
-        @username
-      end
-
-      private
-
-      # 从客户端获取用户名
-      def get_username_from_client
-        if @client && @client.token
-          # 从 token 中获取用户名
-          token_info = @client.token
-          if token_info.is_a?(Hash) && token_info['username']
-            return token_info['username']
-          end
-        end
-        nil
-      end
-    end
-  end
-end