pindo 5.13.12 → 5.13.13

data/lib/pindo/module/task/task_reporter.rb

@@ -0,0 +1,135 @@
+require 'pindo/base/funlog'
+
+module Pindo
+  module TaskSystem
+    # TaskReporter - 任务报告输出
+    #
+    # 职责：
+    # - 输出任务执行计划
+    # - 输出任务进度信息
+    # - 输出任务执行摘要
+    # - 格式化任务状态显示
+    class TaskReporter
+      def initialize(queue)
+        @queue = queue
+      end
+
+      # 输出任务执行计划
+      # @param strategy [Object] 执行策略（响应 :name 方法）
+      def print_execution_plan(strategy)
+        # 获取待执行任务的快照（按类型分组）
+        tasks_by_type = @queue.pending_grouped_by_type
+
+        puts "\n"
+        puts "\e[34m" + "=" * 60
+        puts "  任务执行计划 (#{strategy.name})"
+        puts "=" * 60
+
+        tasks_by_type.each do |type, tasks|
+          # 直接从任务类获取显示名称
+          type_name = if tasks.first&.class&.respond_to?(:task_type_name)
+                        tasks.first.class.task_type_name
+                      else
+                        type.to_s.capitalize
+                      end
+          puts "\n  #{type_name}: #{tasks.count} 个任务"
+
+          # 显示该类型下的每个任务名称
+          tasks.each do |task|
+            puts "    - #{task.name}"
+          end
+        end
+
+        puts "\n  总计: #{@queue.pending_count} 个任务"
+        puts "=" * 60 + "\e[0m"
+        puts "\n"
+      end
+
+      # 输出任务执行头部
+      # @param task [PindoTask] 任务对象
+      def print_task_header(task)
+        puts ""
+        puts "\e[34m▶ #{task.name}\e[0m"
+        puts "─" * 60
+      end
+
+      # 输出任务成功信息
+      # @param task [PindoTask] 任务对象
+      def print_task_success(task)
+        time_str = task.execution_time ? task.execution_time.round(2) : 0
+        puts ""
+        puts "\e[32m✓ #{task.name} 完成 (#{time_str}s)\e[0m"
+      end
+
+      # 输出任务失败信息
+      # @param task [PindoTask] 任务对象
+      # @param error [Exception] 错误对象
+      def print_task_failure(task, error)
+        puts "\n"
+        Funlog.error("任务失败: #{task.name}")
+        Funlog.error("错误信息: #{error.message}")
+
+        # 打印堆栈信息用于调试（仅在 PINDO_DEBUG 模式下）
+        if ENV['PINDO_DEBUG'] && error.backtrace && !error.backtrace.empty?
+          puts "\n堆栈信息:"
+          error.backtrace.first(10).each do |line|
+            puts "  #{line}"
+          end
+        end
+      end
+
+      # 输出任务底部分隔线
+      def print_task_footer
+        # 简化输出，不需要额外的分隔线
+      end
+
+      # 输出执行摘要
+      def print_execution_summary
+        completed = @queue.completed_snapshot
+        success_count = completed.count { |t| t.status == TaskStatus::SUCCESS }
+        failed_count = completed.count { |t| t.status == TaskStatus::FAILED }
+        cancelled_count = completed.count { |t| t.status == TaskStatus::CANCELLED }
+
+        # 获取失败和取消的任务
+        failed_tasks = completed.select { |t| t.status == TaskStatus::FAILED }
+        cancelled_tasks = completed.select { |t| t.status == TaskStatus::CANCELLED }
+
+        # 计算总耗时
+        total_time = completed.map(&:execution_time).compact.sum
+        minutes = (total_time / 60).to_i
+        seconds = (total_time % 60).to_i
+
+        puts "\n"
+        puts "\e[34m" + "=" * 60
+        puts "\e[34m" + "  任务执行完成"
+        puts "\e[34m" + "=" * 60
+
+        # 显示统计信息
+        puts "\e[34m" + "  成功: #{success_count} 个任务" + "\e[0m" if success_count > 0
+
+        if failed_count > 0
+          puts "\e[31m" + "  失败: #{failed_count} 个任务" + "\e[0m"
+          failed_tasks.each do |task|
+            puts "\e[31m" + "    - #{task.name}" + "\e[0m"
+          end
+        end
+
+        if cancelled_count > 0
+          puts "\e[33m" + "  取消: #{cancelled_count} 个任务" + "\e[0m"
+          cancelled_tasks.each do |task|
+            puts "\e[33m" + "    - #{task.name}" + "\e[0m"
+          end
+        end
+
+        if minutes > 0
+          puts "\e[34m" + "  总耗时: #{minutes}分#{seconds}秒" + "\e[0m"
+        else
+          puts "\e[34m" + "  总耗时: #{seconds}秒" + "\e[0m"
+        end
+
+        puts "\e[34m" + "=" * 60 + "\e[0m"
+        puts "\n"
+      end
+    end
+  end
+end

data/lib/pindo/module/task/task_resources/resource_instance.rb

@@ -0,0 +1,90 @@
+require_relative 'resource_type'
+
+module Pindo
+  module TaskSystem
+    module TaskResources
+      # 资源实例 - 表示一个具体的资源占用
+      #
+      # 职责：
+      # - 包含资源类型和上下文信息
+      # - 提供资源冲突检查接口
+      #
+      # 示例：
+      #   xcode_resource = ResourceInstance.new(xcode_type, { directory: "/path/to/project" })
+      #   network_resource = ResourceInstance.new(network_type, {})
+      class ResourceInstance
+        attr_reader :type, :context
+
+        # @param type [ResourceType] 资源类型对象
+        # @param context [Hash] 上下文信息（如 { directory: "/path/to/project" }）
+        def initialize(type, context = {})
+          raise ArgumentError, "type must be a ResourceType" unless type.is_a?(ResourceType)
+          @type = type
+          @context = context || {}
+        end
+
+        # 检查是否与另一个资源实例冲突
+        # @param other [ResourceInstance] 另一个资源实例
+        # @return [Boolean] 是否冲突
+        def conflicts_with?(other)
+          return false unless other.is_a?(ResourceInstance)
+          return false unless @type.name == other.type.name  # 不同类型不冲突
+
+          # 委托给资源类型检查冲突逻辑
+          @type.conflicts?(self, other)
+        end
+
+        # 检查是否匹配另一个资源实例（用于释放资源时查找）
+        # @param other [ResourceInstance] 另一个资源实例
+        # @return [Boolean] 是否匹配
+        def matches?(other)
+          return false unless other.is_a?(ResourceInstance)
+          return false unless @type.name == other.type.name
+
+          # 上下文必须完全匹配
+          @context == other.context
+        end
+
+        # 检查是否匹配资源规格（Hash 格式）
+        # @param spec [Hash] 资源规格，如 { type: :xcode, directory: "/path" }
+        # @return [Boolean] 是否匹配
+        def matches_spec?(spec)
+          return false unless spec.is_a?(Hash)
+          return false unless spec[:type] == @type.name
+
+          # 提取上下文（除了 :type 之外的所有键）
+          spec_context = spec.reject { |k, _| k == :type }
+          @context == spec_context
+        end
+
+        # 资源实例的字符串表示
+        # @return [String]
+        def to_s
+          if @context.empty?
+            "#{@type.name}"
+          else
+            "#{@type.name}(#{@context.inspect})"
+          end
+        end
+
+        # 资源实例的详细描述
+        # @return [String]
+        def inspect
+          "#<ResourceInstance type=#{@type.name} strategy=#{@type.strategy} context=#{@context.inspect}>"
+        end
+
+        # 获取目录路径（如果有）
+        # @return [String, nil]
+        def directory
+          @context[:directory]
+        end
+
+        # 检查是否有目录上下文
+        # @return [Boolean]
+        def has_directory?
+          !@context[:directory].nil?
+        end
+      end
+    end
+  end
+end

data/lib/pindo/module/task/task_resources/resource_registry.rb

@@ -0,0 +1,105 @@
+require_relative 'types/directory_based_resource'
+require_relative 'types/global_exclusive_resource'
+require_relative 'types/global_shared_resource'
+
+module Pindo
+  module TaskSystem
+    module TaskResources
+      # 资源类型注册表
+      #
+      # 职责：
+      # - 管理所有已注册的资源类型
+      # - 提供资源类型查询接口
+      # - 注册内置资源类型
+      class ResourceRegistry
+        def initialize
+          @types = {}
+          register_builtin_types
+        end
+
+        # 注册资源类型
+        # @param name [Symbol] 资源名称
+        # @param type [ResourceType] 资源类型对象
+        def register(name, type)
+          raise ArgumentError, "type must be a ResourceType" unless type.is_a?(ResourceType)
+          @types[name] = type
+        end
+
+        # 获取资源类型
+        # @param name [Symbol] 资源名称
+        # @return [ResourceType] 资源类型对象
+        # @raise [ArgumentError] 如果资源类型不存在
+        def get(name)
+          @types[name] or raise ArgumentError, "Unknown resource type: #{name}"
+        end
+
+        # 检查资源类型是否已注册
+        # @param name [Symbol] 资源名称
+        # @return [Boolean]
+        def registered?(name)
+          @types.key?(name)
+        end
+
+        # 获取所有已注册的资源名称
+        # @return [Array<Symbol>]
+        def all_names
+          @types.keys
+        end
+
+        # 获取所有资源类型对象
+        # @return [Array<ResourceType>]
+        def all_types
+          @types.values
+        end
+
+        private
+
+        # 注册内置资源类型
+        def register_builtin_types
+          # ========================================
+          # 基于目录的资源（相同目录互斥，不同目录可并行）
+          # ========================================
+
+          # 通用构建资源（锁定 git 仓库或项目目录）
+          # 确保同一项目下的所有构建任务串行执行
+          register(:build, DirectoryBasedResourceType.new(:build))
+
+          # Xcode 构建工具
+          register(:xcode, DirectoryBasedResourceType.new(:xcode))
+
+          # Git 版本控制
+          register(:git, DirectoryBasedResourceType.new(:git))
+
+          # Unity 编辑器
+          register(:unity, DirectoryBasedResourceType.new(:unity))
+
+          # Gradle 构建工具
+          register(:gradle, DirectoryBasedResourceType.new(:gradle))
+
+          # ========================================
+          # 全局互斥资源（任何时候只能一个任务使用）
+          # ========================================
+
+          # Keychain 操作
+          register(:keychain, GlobalExclusiveResourceType.new(:keychain))
+
+          # 证书操作
+          register(:certificate, GlobalExclusiveResourceType.new(:certificate))
+
+          # ========================================
+          # 全局共享资源（无限制并发）
+          # ========================================
+
+          # 网络操作
+          register(:network, GlobalSharedResourceType.new(:network))
+
+          # App Store Connect API
+          register(:appstore_connect, GlobalSharedResourceType.new(:appstore_connect))
+
+          # 文件系统操作
+          register(:file_system, GlobalSharedResourceType.new(:file_system))
+        end
+      end
+    end
+  end
+end

data/lib/pindo/module/task/task_resources/resource_type.rb

@@ -0,0 +1,59 @@
+module Pindo
+  module TaskSystem
+    module TaskResources
+      # 资源类型基类
+      #
+      # 职责：
+      # - 定义资源的冲突检查逻辑
+      # - 子类实现不同的冲突策略
+      #
+      # 资源冲突策略：
+      # - :directory_based - 基于目录的资源（相同目录互斥，不同目录可并行）
+      # - :global_exclusive - 全局互斥资源（任何时候只能一个任务使用）
+      # - :global_shared - 全局共享资源（无限制并发）
+      class ResourceType
+        attr_reader :name, :strategy
+
+        # @param name [Symbol] 资源名称
+        # @param strategy [Symbol] 冲突策略
+        def initialize(name, strategy)
+          @name = name
+          @strategy = strategy
+        end
+
+        # 检查两个资源实例是否冲突（抽象方法，子类必须实现）
+        # @param instance1 [ResourceInstance] 资源实例1
+        # @param instance2 [ResourceInstance] 资源实例2
+        # @return [Boolean] 是否冲突
+        # @raise [NotImplementedError] 如果子类未实现
+        def conflicts?(instance1, instance2)
+          raise NotImplementedError, "#{self.class} must implement #conflicts?"
+        end
+
+        # 资源类型的字符串表示
+        # @return [String]
+        def to_s
+          "#{@name}(#{@strategy})"
+        end
+
+        # 检查是否为基于目录的资源
+        # @return [Boolean]
+        def directory_based?
+          @strategy == :directory_based
+        end
+
+        # 检查是否为全局互斥资源
+        # @return [Boolean]
+        def global_exclusive?
+          @strategy == :global_exclusive
+        end
+
+        # 检查是否为全局共享资源
+        # @return [Boolean]
+        def global_shared?
+          @strategy == :global_shared
+        end
+      end
+    end
+  end
+end

data/lib/pindo/module/task/task_resources/types/directory_based_resource.rb

@@ -0,0 +1,63 @@
+require_relative '../resource_type'
+
+module Pindo
+  module TaskSystem
+    module TaskResources
+      # 基于目录的资源类型
+      #
+      # 特性：
+      # - 相同目录的资源互斥（不能并发）
+      # - 不同目录的资源可以并行
+      #
+      # 适用资源：
+      # - Xcode（相同项目目录互斥）
+      # - Git（相同仓库目录互斥）
+      # - Unity（相同项目目录互斥）
+      # - Gradle（相同项目目录互斥）
+      class DirectoryBasedResourceType < ResourceType
+        # @param name [Symbol] 资源名称
+        def initialize(name)
+          super(name, :directory_based)
+        end
+
+        # 检查两个资源实例是否冲突
+        # 规则：
+        # 1. 如果任一资源未指定目录，视为全局冲突（为了安全起见，防止漏锁）
+        # 2. 相同目录冲突
+        # 3. 不同目录不冲突
+        #
+        # @param instance1 [ResourceInstance]
+        # @param instance2 [ResourceInstance]
+        # @return [Boolean]
+        def conflicts?(instance1, instance2)
+          dir1 = instance1.context[:directory]
+          dir2 = instance2.context[:directory]
+
+          # 修改：如果任一资源没有指定目录，视为冲突（Fail-safe 策略）
+          # 这确保了如果某个任务忘记或者无法指定目录，它会独占该类型资源，而不是并发执行
+          return true if dir1.nil? || dir2.nil?
+
+          # 规范化路径后比较
+          normalize_path(dir1) == normalize_path(dir2)
+        end
+
+        private
+
+        # 规范化路径（展开相对路径、软链接等）
+        # @param path [String] 原始路径
+        # @return [String] 规范化后的绝对路径
+        def normalize_path(path)
+          return nil if path.nil?
+          
+          # 尝试获取真实路径（解决软链接问题）
+          begin
+            File.realpath(File.expand_path(path))
+          rescue
+            # 如果文件不存在，回退到 expand_path
+            File.expand_path(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pindo/module/task/task_resources/types/global_exclusive_resource.rb

@@ -0,0 +1,33 @@
+require_relative '../resource_type'
+
+module Pindo
+  module TaskSystem
+    module TaskResources
+      # 全局互斥资源类型
+      #
+      # 特性：
+      # - 任何时候只能有一个任务占用
+      # - 任意两个实例都冲突
+      #
+      # 适用资源：
+      # - Keychain（系统级密钥链，全局唯一）
+      # - Certificate（证书操作，全局互斥）
+      class GlobalExclusiveResourceType < ResourceType
+        # @param name [Symbol] 资源名称
+        def initialize(name)
+          super(name, :global_exclusive)
+        end
+
+        # 检查两个资源实例是否冲突
+        # 规则：永远冲突（全局互斥）
+        #
+        # @param instance1 [ResourceInstance]
+        # @param instance2 [ResourceInstance]
+        # @return [Boolean] 永远返回 true
+        def conflicts?(instance1, instance2)
+          true  # 全局互斥，任意两个实例都冲突
+        end
+      end
+    end
+  end
+end

data/lib/pindo/module/task/task_resources/types/global_shared_resource.rb

@@ -0,0 +1,34 @@
+require_relative '../resource_type'
+
+module Pindo
+  module TaskSystem
+    module TaskResources
+      # 全局共享资源类型
+      #
+      # 特性：
+      # - 无限制并发
+      # - 任意两个实例都不冲突
+      #
+      # 适用资源：
+      # - Network（网络操作，可以并发）
+      # - AppStore Connect（API 调用，可以并发）
+      # - File System（文件系统读取，可以并发）
+      class GlobalSharedResourceType < ResourceType
+        # @param name [Symbol] 资源名称
+        def initialize(name)
+          super(name, :global_shared)
+        end
+
+        # 检查两个资源实例是否冲突
+        # 规则：永不冲突（全局共享）
+        #
+        # @param instance1 [ResourceInstance]
+        # @param instance2 [ResourceInstance]
+        # @return [Boolean] 永远返回 false
+        def conflicts?(instance1, instance2)
+          false  # 全局共享，永不冲突
+        end
+      end
+    end
+  end
+end

data/lib/pindo/module/xcode/xcode_build_helper.rb

@@ -452,14 +452,18 @@ module Pindo
             # 修复 Xcode 16 链接器兼容性问题
             fix_xcode16_linker_flags(project_dir: project_dir)
 
-            # 清理旧的 build 目录
+            # 清理旧的 build 目录 (使用绝对路径)
             build_dir = File.join(project_dir, "build")
             FileUtils.rm_rf(build_dir) if File.exist?(build_dir)
+            
+            # 手动创建输出目录
+            FileUtils.mkdir_p(build_dir)
 
-            # 获取构建参数
+            # 获取构建参数 (传入 output_directory)
             gym_options = get_gym_build_options(
                 project_fullname: project_fullname,
-                icloud_id: icloud_id
+                icloud_id: icloud_id,
+                output_directory: build_dir
             )
 
             # 执行构建
@@ -468,7 +472,7 @@ module Pindo
             Gym::Manager.new.work(config)
 
             # 查找生成的 IPA 文件
-            build_path = File.join(project_dir, "build", "*.ipa")
+            build_path = File.join(build_dir, "*.ipa")
             ipa_file = Dir.glob(build_path).max_by { |f| File.mtime(f) }
 
             ipa_file
@@ -477,14 +481,20 @@ module Pindo
         # 获取 Gym 构建参数
         # @param project_fullname [String] 工程文件完整路径
         # @param icloud_id [String, nil] iCloud ID（可选）
+        # @param output_directory [String] 输出目录绝对路径
         # @return [Hash] Gym 构建参数
-        def get_gym_build_options(project_fullname:, icloud_id: nil)
+        def get_gym_build_options(project_fullname:, icloud_id: nil, output_directory: nil)
             if project_fullname.nil?
                 raise "请指定要编译的工程"
             end
 
             project_path = File.dirname(project_fullname)
             proj_name = File.basename(project_fullname, ".xcodeproj")
+            
+            # 使用绝对路径
+            project_fullname_abs = File.expand_path(project_fullname)
+            project_path_abs = File.dirname(project_fullname_abs)
+            
             project_obj = Xcodeproj::Project.open(project_fullname)
 
             project_build_platform = project_obj.root_object.build_configuration_list.get_setting("SDKROOT")["Release"]
@@ -533,14 +543,22 @@ module Pindo
             app_ipaname_temp = app_ipaname_temp.gsub(/ /, '')
             app_ipaname_temp = app_ipaname_temp.gsub(/\'/, '')
 
+            # 确保输出目录是绝对路径
+            output_directory ||= File.join(project_path_abs, "build")
+            output_directory = File.expand_path(output_directory)
+
             # 构建基本参数
             values = {
-                project: "#{proj_name}.xcodeproj",
+                # 虽然 gym 支持 absolute path，但是为了保险起见，如果提供了 abs path project_fullname，
+                # 我们这里还是传 relative 给 gym，但是我们在调用 gym 之前不 chdir。
+                # 实际上 gym 的 behavior: 如果 project 是 relative，它相对于 cwd。
+                # 所以我们必须给 gym 传入 ABSOLUTE PATH 的 project 才能避免 chdir 问题。
+                project: project_fullname_abs,
                 scheme: "#{proj_name}",
                 configuration: "Release",
                 clean: true,
                 export_method: build_type,
-                output_directory: "./build/",
+                output_directory: output_directory,
                 output_name: "#{app_ipaname_temp}.ipa"
             }
 
@@ -552,7 +570,7 @@ module Pindo
 
             # 如果使用 CocoaPods
             if File.exist?(File.join(project_path, "Podfile"))
-                values[:workspace] = "#{proj_name}.xcworkspace"
+                values[:workspace] = File.join(project_path_abs, "#{proj_name}.xcworkspace")
                 values[:project] = nil
             end
 

data/lib/pindo/options/groups/jps_options.rb

@@ -69,6 +69,16 @@ module Pindo
             env_name: 'PINDO_CERT_ID',
             optional: true,
             example: 'pindo jps resign --certid=com.test.bundleid'
+          ),
+
+          media: OptionItem.new(
+            key: :media,
+            name: '上传媒体附件',
+            description: '上传完成后，从 JPSMedia/ 目录上传媒体附件（图片、视频）',
+            type: OptionItem::Boolean,
+            env_name: 'PINDO_UPLOAD_MEDIA',
+            optional: true,
+            example: 'pindo ios autobuild --media'
           )
         }
       end

data/lib/pindo/options/groups/task_options.rb

@@ -0,0 +1,39 @@
+require 'pindo/options/core/option_item'
+require 'pindo/options/groups/option_group'
+
+module Pindo
+  module Options
+    # Task 任务参数组
+    # 定义任务系统特有的参数
+    module TaskOptions
+      extend OptionGroup
+
+      def self.all_options
+        @all_options ||= {
+          multi: OptionItem.new(
+            key: :multi,
+            name: '并发执行',
+            description: '使用并发任务系统执行构建（提高构建速度）',
+            type: OptionItem::Boolean,
+            env_name: 'PINDO_TASK_MULTI',
+            default_value: false,
+            optional: true,
+            cache: false,  # 不缓存该参数，每次都需要显式指定
+            example: 'pindo unity autobuild --multi'
+          ),
+
+          select: OptionItem.new(
+            key: :select,
+            name: '选择提交',
+            description: '交互式选择历史 git commit（而不是使用 HEAD）',
+            type: OptionItem::Boolean,
+            env_name: 'PINDO_TASK_SELECT',
+            default_value: false,
+            optional: true,
+            example: 'pindo jps media --select'
+          )
+        }
+      end
+    end
+  end
+end

data/lib/pindo/version.rb

@@ -6,13 +6,13 @@ require 'time'
 
 module Pindo
 
-  VERSION = "5.13.12"
+  VERSION = "5.13.13"
 
   class VersionCheck
     RUBYGEMS_API = 'https://rubygems.org/api/v1/gems/pindo.json'
     VERSION_INFO_FILE = File.expand_path('~/.pindo/version_info.yml')
     CHECK_INTERVAL = 5 * 60 * 60   # 5小时检查一次
-    CONFIG_MIN_VERSION = '1.1.0'  # 硬编码的配置版本要求
+    CONFIG_MIN_VERSION = '1.2.0'  # 硬编码的配置版本要求
 
     class << self
       # 主版本检查方法（保持向后兼容）
@@ -187,6 +187,7 @@ module Pindo
         # 创建 HTTP 连接，禁用代理
         http = Net::HTTP.new(uri.host, uri.port, nil, nil)
         http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE # 忽略 SSL 证书验证
         http.open_timeout = 3  # 3秒超时
         http.read_timeout = 3