easyai 1.0.2 → 1.0.3

data/lib/easyai/base/system_keychain.rb

@@ -0,0 +1,240 @@
+require 'rbconfig'
+
+module EasyAI
+  module Base
+    module SystemKeychain
+      SERVICE_NAME = "easyai"
+      ACCOUNT_NAME = "config_password"
+      
+      # 跨平台密码存储
+      def self.store_password(password)
+        case detect_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 detect_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 detect_platform
+        when :macos
+          delete_password_macos
+        when :windows
+          delete_password_windows
+        when :linux
+          delete_password_linux
+        else
+          true
+        end
+      end
+      
+      # 检测操作系统平台
+      def self.detect_platform
+        os = RbConfig::CONFIG['host_os']
+        case os
+        when /darwin/i
+          :macos
+        when /mswin|mingw|cygwin/i
+          :windows
+        when /linux/i
+          :linux
+        else
+          :unknown
+        end
+      end
+      
+      private
+      
+      # macOS Keychain 密码存储
+      def self.store_password_macos(password)
+        # 首先尝试更新现有条目
+        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"
+        end
+        
+        success
+      rescue => e
+        puts "⚠ Keychain 存储出错: #{e.message}"
+        false
+      end
+      
+      # macOS Keychain 密码获取
+      def self.get_password_macos
+        cmd = "security find-generic-password -a '#{ACCOUNT_NAME}' -s '#{SERVICE_NAME}' -w 2>/dev/null"
+        password = `#{cmd}`.chomp
+        
+        return nil if password.empty? || $?.exitstatus != 0
+        password
+      rescue => e
+        nil
+      end
+      
+      # macOS Keychain 密码删除
+      def self.delete_password_macos
+        cmd = "security delete-generic-password -a '#{ACCOUNT_NAME}' -s '#{SERVICE_NAME}' 2>/dev/null"
+        success = system(cmd)
+        
+        if success
+          puts "✓ 已从 macOS Keychain 删除存储的密码"
+        end
+        
+        success
+      rescue => e
+        false
+      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")
+        
+        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} >nul 2>&1"
+        return nil unless system(check_cmd)
+        
+        # 使用 PowerShell 获取密码（简化版本，兼容性更好）
+        ps_script = <<~PS
+          try {
+            $credential = Get-StoredCredential -Target "#{target_name}" -ErrorAction Stop
+            $ptr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($credential.Password)
+            $password = [Runtime.InteropServices.Marshal]::PtrToStringAuto($ptr)
+            [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($ptr)
+            Write-Output $password
+          } catch {
+            # 如果 Get-StoredCredential 不可用，尝试使用原生方法
+            $output = & cmdkey /list:"#{target_name}" 2>$null
+            if ($output -match "User: #{ACCOUNT_NAME}") {
+              Write-Output "CREDENTIAL_EXISTS_BUT_CANNOT_RETRIEVE"
+            }
+          }
+        PS
+        
+        password = `powershell -Command "#{ps_script}" 2>nul`.chomp
+        
+        # 如果无法获取密码但凭据存在，返回特殊标识
+        return nil if password.empty? || password == "CREDENTIAL_EXISTS_BUT_CANNOT_RETRIEVE"
+        password
+      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")
+        
+        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)
+          File.chmod(0600, keyring_file) # 设置为仅用户可读写
+          
+          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/base/update_notifier.rb

@@ -0,0 +1,129 @@
+require 'yaml'
+require 'time'
+
+module EasyAI
+  module Base
+    class UpdateNotifier
+      NOTIFICATION_FILE = File.expand_path('~/.easyai/update_notification.yml')
+      
+      class << self
+        # 智能决定是否显示更新通知
+        def maybe_show_notification
+          return if ENV['EASYAI_NO_UPDATE_CHECK']
+          return unless should_show_notification?
+          
+          notification = load_notification
+          return unless notification && notification['available']
+          
+          # 使用简洁的单行提醒
+          show_brief_notification(notification)
+          update_shown_time
+        end
+        
+        # 在程序退出时显示（如果有更新）
+        def show_on_exit
+          return if ENV['EASYAI_NO_UPDATE_CHECK']
+          
+          notification = load_notification
+          return unless notification && notification['available']
+          return if notification['shown_today']
+          
+          # 退出时显示稍微详细的信息
+          show_exit_notification(notification)
+          mark_as_shown_today
+        end
+        
+        private
+        
+        def should_show_notification?
+          notification = load_notification
+          return false unless notification
+          
+          # 检查显示频率
+          last_shown = notification['last_shown_at']
+          if last_shown
+            hours_since = (Time.now - Time.parse(last_shown)) / 3600
+            
+            # 根据版本差异决定提醒频率
+            if major_update?(notification)
+              return hours_since > 6  # 主版本更新：6小时提醒一次
+            elsif minor_update?(notification)
+              return hours_since > 24  # 次版本更新：24小时提醒一次
+            else
+              return hours_since > 72  # 补丁更新：72小时提醒一次
+            end
+          end
+          
+          true
+        end
+        
+        def major_update?(notification)
+          return false unless notification['latest_version'] && notification['current_version']
+          
+          latest_major = notification['latest_version'].split('.')[0].to_i
+          current_major = notification['current_version'].split('.')[0].to_i
+          
+          latest_major > current_major
+        end
+        
+        def minor_update?(notification)
+          return false unless notification['latest_version'] && notification['current_version']
+          
+          latest_parts = notification['latest_version'].split('.').map(&:to_i)
+          current_parts = notification['current_version'].split('.').map(&:to_i)
+          
+          latest_parts[0] == current_parts[0] && latest_parts[1] > current_parts[1]
+        end
+        
+        def show_brief_notification(notification)
+          latest = notification['latest_version']
+          current = notification['current_version']
+          
+          # 单行简洁提醒
+          if major_update?(notification)
+            puts "💡 重要更新: EasyAI #{latest} 已发布 (当前: #{current})。运行 'gem update easyai' 更新。".yellow
+          else
+            puts "💡 新版本: EasyAI #{latest} 可用。运行 'easyai --check-update' 查看详情。".cyan
+          end
+        end
+        
+        def show_exit_notification(notification)
+          latest = notification['latest_version']
+          current = notification['current_version']
+          
+          puts "\n" + "─" * 50
+          puts "📦 EasyAI 更新提醒".yellow
+          puts "  当前版本: #{current}"
+          puts "  最新版本: #{latest}".green
+          puts "  更新命令: gem update easyai"
+          puts "  查看详情: easyai --check-update"
+          puts "─" * 50
+        end
+        
+        def load_notification
+          return nil unless File.exist?(NOTIFICATION_FILE)
+          YAML.load_file(NOTIFICATION_FILE) rescue nil
+        end
+        
+        def update_shown_time
+          notification = load_notification || {}
+          notification['last_shown_at'] = Time.now.to_s
+          save_notification(notification)
+        end
+        
+        def mark_as_shown_today
+          notification = load_notification || {}
+          notification['shown_today'] = Date.today.to_s
+          save_notification(notification)
+        end
+        
+        def save_notification(data)
+          FileUtils.mkdir_p(File.dirname(NOTIFICATION_FILE))
+          File.write(NOTIFICATION_FILE, data.to_yaml)
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/easyai/base/version_checker.rb

@@ -0,0 +1,329 @@
+require 'net/http'
+require 'json'
+require 'yaml'
+require 'fileutils'
+require 'time'
+require 'colored2'
+
+module EasyAI
+  module Base
+    class VersionChecker
+      RUBYGEMS_API = 'https://rubygems.org/api/v1/gems/easyai.json'
+      CACHE_FILE = File.expand_path('~/.easyai/version_cache.yml')
+      CHECK_INTERVAL = 24 * 60 * 60  # 24小时检查一次
+      
+      class << self
+        # 异步检查版本（不阻塞主程序）
+        def check_async
+          puts "  🔮 启动异步版本检查...".cyan if ENV['EASYAI_DEBUG']
+          
+          return unless should_check?
+          
+          puts "  🚀 后台检查进程已启动".green if ENV['EASYAI_DEBUG']
+          
+          # 使用 fork 在后台检查（Unix系统）
+          if Process.respond_to?(:fork)
+            pid = fork do
+              # 子进程中执行检查
+              check_and_cache
+              exit(0)
+            end
+            # 父进程立即继续，不等待子进程
+            Process.detach(pid) if pid
+          else
+            # Windows 系统使用线程
+            Thread.new { check_and_cache }
+          end
+        end
+        
+        # 检查是否需要强制更新
+        def require_force_update?
+          return false if ENV['EASYAI_SKIP_FORCE_UPDATE']  # 紧急跳过选项
+          
+          # 检查缓存
+          if File.exist?(CACHE_FILE)
+            cache = YAML.load_file(CACHE_FILE) rescue {}
+            latest = cache['latest_version']
+            current = cache['current_version'] || EasyAI::VERSION
+            
+            return needs_major_or_minor_update?(latest, current)
+          end
+          
+          false
+        rescue
+          false
+        end
+        
+        # 强制更新检查（同步）
+        def check_force_update!
+          puts "  📌 执行强制更新检查...".cyan if ENV['EASYAI_DEBUG']
+          
+          # 如果缓存中已有需要强制更新的信息，直接使用
+          if require_force_update?
+            cache = YAML.load_file(CACHE_FILE) rescue {}
+            show_force_update_message(cache['latest_version'], EasyAI::VERSION)
+            exit(1)
+          end
+          
+          # 如果缓存过期或不存在，立即检查
+          if should_check_immediately?
+            puts "  🔄 正在从 RubyGems 获取最新版本...".cyan if ENV['EASYAI_DEBUG']
+            latest = fetch_latest_version
+            if latest && needs_major_or_minor_update?(latest, EasyAI::VERSION)
+              # 更新缓存
+              update_cache_for_force_update(latest, EasyAI::VERSION)
+              show_force_update_message(latest, EasyAI::VERSION)
+              exit(1)
+            end
+          else
+            puts "  💾 使用缓存（未过期）".light_black if ENV['EASYAI_DEBUG']
+          end
+        end
+        
+        # 同步检查版本（用于 --check-update 命令）
+        def check_now
+          latest = fetch_latest_version
+          current = EasyAI::VERSION
+          
+          if latest && newer_version?(latest, current)
+            show_update_message(latest, current)
+            true
+          else
+            puts "✓ 您正在使用最新版本 (#{current})".green
+            false
+          end
+        rescue => e
+          puts "⚠ 无法检查更新: #{e.message}".yellow if ENV['DEBUG']
+          false
+        end
+        
+        # 显示缓存的更新提醒（如果有）
+        def show_cached_reminder
+          return unless File.exist?(CACHE_FILE)
+          
+          cache = YAML.load_file(CACHE_FILE) rescue {}
+          return unless cache['new_version_available']
+          return if cache['reminder_shown_at'] && 
+                   Time.now - Time.parse(cache['reminder_shown_at']) < 3600  # 1小时内不重复提醒
+          
+          latest = cache['latest_version']
+          current = EasyAI::VERSION
+          
+          if newer_version?(latest, current)
+            puts "\n#{get_update_banner(latest, current)}\n"
+            
+            # 更新提醒时间
+            cache['reminder_shown_at'] = Time.now.to_s
+            save_cache(cache)
+          end
+        end
+        
+        private
+        
+        def should_check?
+          return false if ENV['EASYAI_NO_UPDATE_CHECK']  # 允许用户禁用
+          
+          # 检查缓存文件
+          if File.exist?(CACHE_FILE)
+            cache = YAML.load_file(CACHE_FILE) rescue {}
+            last_check = cache['last_check_at']
+            if last_check
+              time_since_check = Time.now - Time.parse(last_check)
+              return time_since_check > CHECK_INTERVAL
+            end
+          end
+          
+          true
+        end
+        
+        def check_and_cache
+          latest = fetch_latest_version
+          return unless latest
+          
+          current = EasyAI::VERSION
+          is_new = newer_version?(latest, current)
+          
+          cache = {
+            'last_check_at' => Time.now.to_s,
+            'latest_version' => latest,
+            'current_version' => current,
+            'new_version_available' => is_new
+          }
+          
+          save_cache(cache)
+          
+          # 同时更新通知文件
+          if is_new
+            update_notification(latest, current)
+          end
+        rescue => e
+          # 静默失败，不影响主程序
+          nil
+        end
+        
+        def update_notification(latest, current)
+          notification_file = File.expand_path('~/.easyai/update_notification.yml')
+          notification = {
+            'available' => true,
+            'latest_version' => latest,
+            'current_version' => current,
+            'checked_at' => Time.now.to_s
+          }
+          
+          # 保留上次显示时间
+          if File.exist?(notification_file)
+            old_data = YAML.load_file(notification_file) rescue {}
+            notification['last_shown_at'] = old_data['last_shown_at']
+            notification['shown_today'] = old_data['shown_today']
+          end
+          
+          FileUtils.mkdir_p(File.dirname(notification_file))
+          File.write(notification_file, notification.to_yaml)
+        rescue
+          nil
+        end
+        
+        def fetch_latest_version
+          uri = URI(RUBYGEMS_API)
+          
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.open_timeout = 2  # 快速超时
+          http.read_timeout = 2
+          
+          request = Net::HTTP::Get.new(uri)
+          response = http.request(request)
+          
+          if response.code == '200'
+            data = JSON.parse(response.body)
+            data['version']
+          else
+            nil
+          end
+        rescue => e
+          nil  # 网络错误时静默失败
+        end
+        
+        def newer_version?(latest, current)
+          return false unless latest && current
+          
+          # 解析版本号 (major.minor.patch)
+          latest_parts = latest.split('.').map(&:to_i)
+          current_parts = current.split('.').map(&:to_i)
+          
+          # 比较版本号
+          (0..2).each do |i|
+            latest_part = latest_parts[i] || 0
+            current_part = current_parts[i] || 0
+            
+            return true if latest_part > current_part
+            return false if latest_part < current_part
+          end
+          
+          false
+        end
+        
+        # 检查是否需要强制更新（主版本或次版本更新）
+        def needs_major_or_minor_update?(latest, current)
+          return false unless latest && current
+          
+          latest_parts = latest.split('.').map(&:to_i)
+          current_parts = current.split('.').map(&:to_i)
+          
+          # 主版本更新（如 1.x.x -> 2.x.x）
+          return true if latest_parts[0] > current_parts[0]
+          
+          # 次版本更新（如 1.1.x -> 1.2.x）
+          return true if latest_parts[0] == current_parts[0] && latest_parts[1] > current_parts[1]
+          
+          false
+        end
+        
+        # 是否应该立即检查
+        def should_check_immediately?
+          return true unless File.exist?(CACHE_FILE)
+          
+          cache = YAML.load_file(CACHE_FILE) rescue {}
+          last_check = cache['last_check_at']
+          
+          # 如果没有检查记录或缓存超过6小时，立即检查
+          return true unless last_check
+          
+          time_since_check = Time.now - Time.parse(last_check)
+          time_since_check > 6 * 60 * 60  # 6小时
+        end
+        
+        # 更新缓存（强制更新场景）
+        def update_cache_for_force_update(latest, current)
+          cache = {
+            'last_check_at' => Time.now.to_s,
+            'latest_version' => latest,
+            'current_version' => current,
+            'new_version_available' => true,
+            'force_update_required' => true
+          }
+          save_cache(cache)
+        end
+        
+        def save_cache(data)
+          FileUtils.mkdir_p(File.dirname(CACHE_FILE))
+          File.write(CACHE_FILE, data.to_yaml)
+        rescue => e
+          # 静默失败
+          nil
+        end
+        
+        def show_update_message(latest, current)
+          puts get_update_banner(latest, current)
+        end
+        
+        def get_update_banner(latest, current)
+          banner = []
+          banner << "┌─────────────────────────────────────────────────────┐".yellow
+          banner << "│ 🎉 新版本可用！                                      │".yellow
+          banner << "│                                                     │".yellow
+          banner << "│   当前版本: #{current.ljust(39)}│".yellow
+          banner << "│   最新版本: #{latest.ljust(39)}│".yellow
+          banner << "│                                                     │".yellow
+          banner << "│   更新方式:                                         │".yellow
+          banner << "│   稳定版: $ gem update easyai                      │".yellow
+          banner << "│   开发版: $ easyai update (仅用于测试)             │".yellow
+          banner << "│                                                     │".yellow
+          banner << "│   禁用检查: export EASYAI_NO_UPDATE_CHECK=1        │".yellow
+          banner << "└─────────────────────────────────────────────────────┘".yellow
+          banner.join("\n")
+        end
+        
+        def show_force_update_message(latest, current)
+          latest_parts = latest.split('.').map(&:to_i)
+          current_parts = current.split('.').map(&:to_i)
+          
+          is_major_update = latest_parts[0] > current_parts[0]
+          update_type = is_major_update ? "主版本" : "次版本"
+          
+          puts "\n"
+          puts "╔═══════════════════════════════════════════════════════════╗".red
+          puts "║                    ⚠️  强制更新要求 ⚠️                      ║".red
+          puts "╠═══════════════════════════════════════════════════════════╣".red
+          puts "║                                                           ║".red
+          puts "║  检测到#{update_type}更新，必须升级后才能继续使用：              ║".red
+          puts "║                                                           ║".red
+          puts "║    当前版本: #{current.ljust(44)}║".red
+          puts "║    最新版本: #{latest.ljust(44)}║".red
+          puts "║                                                           ║".red
+          puts "║  此更新包含重要变更，为确保功能正常，请立即更新：         ║".red
+          puts "║                                                           ║".red
+          puts "║    稳定版: $ gem update easyai                           ║".red
+          puts "║    开发版: $ easyai update (临时测试)                    ║".red
+          puts "║                                                           ║".red
+          puts "║  如遇紧急情况需要临时跳过（不推荐）：                     ║".red
+          puts "║    $ export EASYAI_SKIP_FORCE_UPDATE=1                   ║".red
+          puts "║                                                           ║".red
+          puts "╚═══════════════════════════════════════════════════════════╝".red
+          puts "\n"
+          puts "程序将退出，请更新后重试。".red
+        end
+      end
+    end
+  end
+end