pindo 5.2.4 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 235be197b7b9f5717b54477a778d7b27387ce4b12d72f3d4cf4bccb7f8267df3
-  data.tar.gz: 619ee059cd180a87cd699417f7a0b3021ee88223ca82565dad183edcbb2df5e7
+  metadata.gz: 56fcfdba92a710c2c7ab85226d30f305cbb1fca5d3fccb57d5c62e6593c8afbb
+  data.tar.gz: a2d7a5c80ca642869ce4f79ef9dca35383b7426c5cf15077937137db899b4eab
 SHA512:
-  metadata.gz: 317f3cc6730620555bfe942315f75261cb91c52706820d65aa81ce76d1abb2ab0fd4861fe0392ed085a3567d4c3307cfd64bd64f3ded724efd776c9011ee3bcd
-  data.tar.gz: fd961b915306b88886c1ae987774da7fc535e55c54f9599221ce5e342ab14182177ea555895de3a9d2277864f28de78935075ee31b99552c7fbb4ab7384a7d2b
+  metadata.gz: 54cef915058ddb2d765e136181c13b1e1e6e1376316e8b443a19e54bf03da4afb7763564348c7fe04099cb87476e3547664016dd479936423243360036a9fbe4
+  data.tar.gz: 86a5729f1929db20b938254ae541c1310fce8dba85d7d0088966f197aad668723c11270775bbdcd8651ca86609d357e69fac7dfd8e6d1459133d58fe9357bccd

data/lib/pindo/base/aeshelper.rb

@@ -8,7 +8,7 @@ module Pindo
   module AESHelper
 
 
-    def self.fetch_password(keychain_name:nil)
+    def self.fetch_password(keychain_name:nil, test_file:nil)
       # password = ENV["MATCH_PASSWORD"]
 
       server_name = ["match", keychain_name].join("_")
@@ -18,9 +18,30 @@ module Pindo
       password = item.password if item
 
       unless password
+          puts "\e[33m[DEBUG] Keychain中未找到密码，需要用户输入: #{server_name}\e[0m" if ENV['PINDO_DEBUG']
           password = FastlaneCore::Helper.ask_password(message: "请输入证书仓库的加密密码: ", confirm: true)
-          Security::InternetPassword.add(server_name, "", password)
+          # 尝试添加密码到Keychain，如果已存在则先删除再添加
+          begin
+            # 先检查是否已存在，如果存在则删除
+            existing_item = Security::InternetPassword.find(server: server_name)
+            if existing_item
+              # 重定向stderr到/dev/null来隐藏Keychain的详细输出
+              system("security delete-internet-password -s '#{server_name}' 2>/dev/null")
+              puts "\e[33m[DEBUG] 删除Keychain中的旧密码项: #{server_name}\e[0m" if ENV['PINDO_DEBUG']
+            end
+            
+            # 添加新密码，重定向stderr到/dev/null来隐藏Keychain的详细输出
+            system("security add-internet-password -s '#{server_name}' -w '#{password}' 2>/dev/null")
+            puts "\e[32m[DEBUG] 密码已保存到Keychain: #{server_name}\e[0m" if ENV['PINDO_DEBUG']
+          rescue => e
+            # 忽略Keychain错误，继续使用密码
+            # 错误信息可能包含 "already exists" 等，但不影响功能
+            puts "\e[31m[DEBUG] Keychain操作错误: #{e.message}\e[0m" if ENV['PINDO_DEBUG']
+          end
+      else
+          puts "\e[32m[DEBUG] 从Keychain获取密码成功: #{server_name}\e[0m" if ENV['PINDO_DEBUG']
       end
+
       return password
     end
 

data/lib/pindo/base/pindocontext.rb

@@ -0,0 +1,476 @@
+require 'singleton'
+require 'digest'
+require 'json'
+require 'fileutils'
+
+module Pindo
+  class PindoContext
+    include Singleton
+
+    attr_reader :current_command, :current_directory
+
+    def initialize
+      @current_command = nil      # 根命令（第一个设置的命令）
+      @current_directory = nil    # 项目路径
+      @memory_selections = {}      # 三级结构的内存缓存
+      @file_cache_loaded = false   # 标记文件缓存是否已加载
+      @cache_enabled = false       # 默认禁用缓存
+      @command_group = nil         # 命令组名称
+      ensure_cache_dir
+    end
+
+    # 设置当前上下文
+    def set_context(command, directory = nil, options = {})
+      # 如果已有命令在执行，这是嵌套调用，不需要做任何事
+      unless @current_command.nil?
+        puts "[PindoContext] 嵌套调用 #{command}，使用已有上下文 (根命令: #{@current_command}，命令组: #{@command_group})"
+        return
+      end
+
+      # 第一次设置，是顶层命令
+      @current_command = command  # 保持原始命令名称
+      @current_directory = directory || Dir.pwd  # 固定项目目录
+
+      # 从选项中获取缓存配置
+      @cache_enabled = options[:cache_enabled] || false
+      # 使用 get_command_group 来确定缓存组
+      @command_group = get_command_group(command)
+
+      puts "\n[PindoContext] ========== 设置顶层命令上下文 =========="
+      puts "[PindoContext] 命令: #{command}"
+      puts "[PindoContext] 目录: #{@current_directory}"
+      puts "[PindoContext] 缓存启用: #{@cache_enabled}"
+      puts "[PindoContext] 命令组: #{@command_group}"
+      puts "[PindoContext] options: #{options.inspect}"
+
+      # 仅在启用缓存时加载文件缓存
+      if @cache_enabled && !@file_cache_loaded
+        puts "[PindoContext] 准备加载文件缓存..."
+        load_file_cache_with_confirmation
+        @file_cache_loaded = true
+      else
+        if !@cache_enabled
+          puts "[PindoContext] 缓存未启用，跳过文件缓存加载"
+        elsif @file_cache_loaded
+          puts "[PindoContext] 文件缓存已加载，跳过重复加载"
+        end
+      end
+      puts "[PindoContext] ======================================\n"
+    end
+
+    # 重置上下文（顶层命令结束时调用）
+    def reset_context
+      # 仅在启用缓存时保存文件缓存
+      save_file_cache if @cache_enabled && @current_command
+
+      @current_command = nil
+      @current_directory = nil
+      @file_cache_loaded = false
+      @cache_enabled = false
+      @command_group = nil
+      # 暂不清理内存缓存，让同一进程内可以复用
+    end
+
+    # 设置用户选择（三级结构：项目路径 -> 根命令 -> 键值）
+    def set_selection(key, value)
+      # 构建三级键 - 使用统一的项目路径获取方法
+      project_path = get_project_path
+      root_command = @command_group || @current_command
+
+      # 如果没有有效的项目路径或命令，不保存
+      unless project_path && root_command
+        puts "[PindoContext] 警告: 无法保存选择，缺少项目路径或命令上下文"
+        return
+      end
+
+      # 初始化三级结构（总是保存到内存，不管是否启用缓存）
+      @memory_selections[project_path] ||= {}
+      @memory_selections[project_path][root_command] ||= {}
+      @memory_selections[project_path][root_command][key] = value
+
+      # 更新该命令组的最后修改时间
+      @memory_selections[project_path][root_command]['__last_modified__'] = Time.now.to_i
+
+      puts "[PindoContext] 保存到内存: [#{project_path}][#{root_command}][#{key}] = #{value.inspect}"
+
+      # 仅在启用缓存时保存到文件
+      if @cache_enabled
+        save_file_cache
+        puts "[PindoContext] 已保存到文件缓存"
+      else
+        puts "[PindoContext] 缓存未启用，仅保存到内存"
+      end
+    end
+
+    # 获取用户选择（三级结构访问）
+    def get_selection(key)
+      # 使用统一的项目路径获取方法
+      project_path = get_project_path
+      root_command = @command_group || @current_command
+
+      return nil unless project_path && root_command
+
+      # 从三级结构中获取值（总是从内存获取，不管是否启用缓存）
+      value = @memory_selections.dig(project_path, root_command, key)
+
+      if value
+        puts "[PindoContext] 从内存获取: [#{project_path}][#{root_command}][#{key}] = #{value.inspect}"
+      else
+        puts "[PindoContext] 内存中未找到: [#{project_path}][#{root_command}][#{key}]" if ENV['PINDO_DEBUG']
+      end
+
+      value
+    end
+
+    # 检查是否有缓存的选择
+    def has_selection?(key)
+      # 总是检查内存中是否有值，不管是否启用缓存
+      !get_selection(key).nil?
+    end
+
+    # 启用/禁用缓存
+    def enable_cache(enabled = true)
+      @cache_enabled = enabled
+      if enabled && !@file_cache_loaded && @current_command
+        load_file_cache_with_confirmation
+        @file_cache_loaded = true
+      end
+    end
+
+    # 检查缓存是否启用
+    def cache_enabled?
+      @cache_enabled
+    end
+
+    # 是否是嵌套调用
+    def nested_call?
+      !@current_command.nil?
+    end
+
+    # 是否是顶层命令（非嵌套）
+    def top_level_command?
+      @current_command.nil?
+    end
+
+    # 获取当前根命令
+    def root_command
+      @command_group || @current_command
+    end
+
+    # 获取当前项目路径（统一的获取方法，确保一致性）
+    def project_path
+      get_project_path
+    end
+
+    # 内部使用的项目路径获取方法
+    # 优先使用已设置的目录，如果没有则尝试获取Git仓库根目录
+    def get_project_path
+      # 如果已经设置了目录，直接返回
+      return @current_directory if @current_directory
+
+      # 尝试获取Git仓库根目录
+      begin
+        git_root = `git rev-parse --show-toplevel 2>/dev/null`.strip
+        return git_root if $?.success? && !git_root.empty?
+      rescue
+        # git命令失败
+      end
+
+      # 最后的后备：使用当前目录
+      Dir.pwd
+    end
+
+    # 清除当前上下文的缓存
+    def clear_current_cache
+      return unless @cache_enabled
+
+      proj_path = get_project_path
+      cmd = root_command
+      return unless proj_path && cmd
+
+      if @memory_selections[proj_path] && @memory_selections[proj_path][cmd]
+        @memory_selections[proj_path].delete(cmd)
+        @memory_selections.delete(proj_path) if @memory_selections[proj_path].empty?
+        save_file_cache
+        puts "[PindoContext] 清除缓存: [#{proj_path}][#{cmd}]" if ENV['PINDO_DEBUG']
+      end
+    end
+
+    # 选择键定义
+    module SelectionKey
+      TAG_DECISION = :tag_decision      # 打Tag决定
+      PROJECT_NAME = :project_name      # 项目名称
+      BUNDLE_ID = :bundle_id            # Bundle ID
+      CERT_TYPE = :cert_type            # 证书类型
+    end
+
+    private
+
+    # 确保缓存目录存在
+    def ensure_cache_dir
+      cache_dir = File.expand_path('~/.pindo/cache')
+      FileUtils.mkdir_p(cache_dir) unless File.exist?(cache_dir)
+    end
+
+    # 获取缓存文件路径
+    def cache_file_path
+      cache_dir = File.expand_path('~/.pindo/cache')
+      File.join(cache_dir, 'context_selections.json')
+    end
+
+    # 加载文件缓存并确认（三级结构）
+    def load_file_cache_with_confirmation
+      file_path = cache_file_path
+
+      puts "[PindoContext] 检查文件缓存: #{file_path}"
+
+      unless File.exist?(file_path)
+        puts "[PindoContext] 文件缓存不存在，跳过加载"
+        return
+      end
+
+      begin
+        file_content = File.read(file_path)
+        file_cache = JSON.parse(file_content)
+
+        # 清理过期缓存（超过7天）
+        file_cache = clean_expired_cache(file_cache)
+
+        # 获取当前项目和命令的缓存
+        project_path = get_project_path
+        root_command = @command_group || @current_command
+
+        puts "[PindoContext] 查找缓存: [#{project_path}][#{root_command}]"
+
+        # 检查三级结构中是否有当前上下文的缓存
+        cached_selections = file_cache.dig(project_path, root_command)
+
+        if cached_selections && !cached_selections.empty?
+          # 根据命令组显示更友好的描述
+          group_desc = case root_command
+                       when 'ios:autobuild'
+                         'iOS 构建'
+                       when 'and:autobuild', 'android:autobuild'
+                         'Android 构建'
+                       when 'web:autobuild'
+                         'Web 构建'
+                       else
+                         @current_command  # 其他命令显示原始命令名
+                       end
+
+          puts "\n检测到之前的选择 (#{group_desc}):"
+          puts "────────────────────────────────────────"
+
+          cached_selections.each do |key, value|
+            # 跳过内部字段
+            next if key.to_s.start_with?('__')
+
+            case key.to_s
+            when 'bundle_id'
+              puts "  Bundle ID: #{value}"
+            when 'project_name', 'app_key'  # 兼容旧的 app_key
+              puts "  项目名称: #{value}"
+            when 'tag_decision'
+              if value.is_a?(Hash)
+                action_desc = value['description'] || value['action']
+                puts "  Tag决定: #{action_desc}"
+              end
+            when 'cert_type'
+              puts "  证书类型: #{value}"
+            end
+          end
+          puts "────────────────────────────────────────"
+
+          # 询问用户是否使用缓存
+          require 'highline/import'
+          cli = HighLine.new
+          confirm = cli.agree("\n是否使用以上缓存的选择？ (y/n) ")
+
+          if confirm
+            puts "使用缓存的选择\n"
+            # 恢复三级结构的文件缓存到内存缓存
+            file_cache.each do |proj_path, commands|
+              @memory_selections[proj_path] ||= {}
+              commands.each do |cmd, selections|
+                @memory_selections[proj_path][cmd] ||= {}
+                selections.each do |key, value|
+                  symbol_key = key.to_sym
+                  @memory_selections[proj_path][cmd][symbol_key] = value
+                end
+              end
+            end
+          else
+            puts "清除缓存，重新选择\n"
+            # 清除当前上下文的文件缓存（三级结构）
+            if file_cache[project_path] && file_cache[project_path][root_command]
+              file_cache[project_path].delete(root_command)
+              # 如果项目路径下没有任何命令缓存了，删除项目路径键
+              file_cache.delete(project_path) if file_cache[project_path].empty?
+            end
+            File.write(file_path, JSON.pretty_generate(file_cache))
+            # 不加载任何缓存到内存
+          end
+        else
+          # 加载整个文件缓存到内存（不需要确认）
+          file_cache.each do |proj_path, commands|
+            @memory_selections[proj_path] ||= {}
+            commands.each do |cmd, selections|
+              # 跳过当前上下文（已经是空的）
+              next if proj_path == project_path && cmd == root_command
+
+              @memory_selections[proj_path][cmd] ||= {}
+              selections.each do |key, value|
+                symbol_key = key.to_sym
+                @memory_selections[proj_path][cmd][symbol_key] = value
+              end
+            end
+          end
+        end
+
+        puts "[PindoContext] 处理文件缓存: #{file_path}" if ENV['PINDO_DEBUG']
+      rescue => e
+        puts "[PindoContext] 加载缓存失败: #{e.message}" if ENV['PINDO_DEBUG']
+      end
+    end
+
+    # 保存文件缓存（三级结构）
+    def save_file_cache
+      file_path = cache_file_path
+
+      begin
+        # 转换内存缓存为可序列化的格式（保持三级结构）
+        file_cache = {}
+        @memory_selections.each do |project_path, commands|
+          file_cache[project_path] ||= {}
+          commands.each do |command, selections|
+            file_cache[project_path][command] ||= {}
+            selections.each do |key, value|
+              # 将符号键转换为字符串
+              string_key = key.to_s
+              file_cache[project_path][command][string_key] = value
+            end
+          end
+        end
+
+        # 写入文件
+        File.write(file_path, JSON.pretty_generate(file_cache))
+
+        puts "[PindoContext] 保存文件缓存: #{file_path}" if ENV['PINDO_DEBUG']
+      rescue => e
+        puts "[PindoContext] 保存缓存失败: #{e.message}" if ENV['PINDO_DEBUG']
+      end
+    end
+
+    # 获取命令组名称（统一管理命令缓存组）
+    def get_command_group(command)
+      # 根据需求文档定义命令组，相关命令共享同一缓存
+      case command
+      # iOS 构建相关命令组
+      when 'unity:ipa'
+        'ios:autobuild'
+
+      # Android 构建相关命令组
+      when 'unity:apk'
+        'and:autobuild'
+
+      # Web 构建相关命令组
+      when 'unity:web'
+        'web:autobuild'
+
+      else
+        command  # 其他命令使用独立缓存（命令名本身作为组）
+      end
+    end
+
+    # 清理过期缓存（超过7天的缓存）
+    def clean_expired_cache(cache_data)
+      return {} unless cache_data.is_a?(Hash)
+
+      current_time = Time.now.to_i
+      seven_days_in_seconds = 7 * 24 * 60 * 60
+      cleaned_cache = {}
+      expired_commands = []
+      expired_projects = []
+
+      cache_data.each do |project_path, commands|
+        # 初始化项目路径
+        cleaned_commands = {}
+
+        commands.each do |command, selections|
+          # 获取最后修改时间
+          last_modified = selections['__last_modified__']
+
+          # 如果没有时间戳，视为过期
+          if last_modified.nil?
+            expired_commands << "[#{project_path}][#{command}] (无时间戳)"
+            puts "[PindoContext] 清理无时间戳缓存: [#{project_path}][#{command}]" if ENV['PINDO_DEBUG']
+            next
+          end
+
+          # 检查是否过期（超过7天）
+          if (current_time - last_modified.to_i) > seven_days_in_seconds
+            days_old = (current_time - last_modified.to_i) / (24 * 60 * 60)
+            expired_commands << "[#{project_path}][#{command}] (#{days_old}天前)"
+            puts "[PindoContext] 清理过期缓存 (#{days_old}天前): [#{project_path}][#{command}]" if ENV['PINDO_DEBUG']
+            next
+          end
+
+          # 保留未过期的缓存
+          cleaned_commands[command] = selections
+        end
+
+        # 如果该项目路径下还有有效的命令缓存，保留它
+        if cleaned_commands.any?
+          cleaned_cache[project_path] = cleaned_commands
+        else
+          # 整个项目路径下的所有命令都过期了，删除整个项目路径
+          expired_projects << project_path
+          puts "[PindoContext] 删除空项目路径: #{project_path}" if ENV['PINDO_DEBUG']
+        end
+      end
+
+      # 输出清理总结
+      if expired_commands.any? || expired_projects.any?
+        puts "[PindoContext] 缓存清理完成:"
+        if expired_commands.any?
+          puts "  - 清理了 #{expired_commands.size} 个过期命令缓存"
+          expired_commands.each { |cmd| puts "    • #{cmd}" } if ENV['PINDO_DEBUG']
+        end
+        if expired_projects.any?
+          puts "  - 删除了 #{expired_projects.size} 个空项目路径"
+          expired_projects.each { |proj| puts "    • #{proj}" } if ENV['PINDO_DEBUG']
+        end
+
+        # 立即保存清理后的缓存到文件
+        File.write(cache_file_path, JSON.pretty_generate(cleaned_cache))
+      end
+
+      cleaned_cache
+    end
+
+
+    public
+
+    # 调试信息
+    def debug_info
+      puts "\n=== PindoContext Debug Info ==="
+      puts "当前命令: #{@current_command || '无'}"
+      puts "命令组: #{@command_group || '无'}"
+      puts "设置的目录: #{@current_directory || '未设置'}"
+      puts "实际项目路径: #{get_project_path}"
+      puts "缓存启用: #{@cache_enabled}"
+
+      proj_path = get_project_path
+      root_cmd = @command_group || @current_command
+
+      if root_cmd && @memory_selections.dig(proj_path, root_cmd)
+        puts "当前缓存的选择:"
+        @memory_selections[proj_path][root_cmd].each do |k, v|
+          next if k.to_s.start_with?('__')  # 跳过内部字段
+          puts "  #{k}: #{v.inspect}"
+        end
+      end
+      puts "================================\n"
+    end
+  end
+end