pindo 5.14.4 → 5.14.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb15b2496f39d434ab25b2609b651779fc38187e56990a40f66aeee02411da83
-  data.tar.gz: c0abb252891099cf6c45bda365737415d662b1d165bb027064779db171c0fbe0
+  metadata.gz: 60289998ea7be5f175400dbd6038a6aebe104095280ee7fe10aba1ea513d20f8
+  data.tar.gz: 1a4fddd44fa17a17716a4e55a9c3ad7df41fed6357934e2b179801779dd7a139
 SHA512:
-  metadata.gz: 3271d2f0516402ea4ee3f8716fe6d1fd4c1d0c1bc46e39ac65ed9c2fb00cb9f707dc44485acafb3e26a28b03b9069681f8a8d31c891534d144de614b53befb42
-  data.tar.gz: 170f1753ee18dd359dea8a8f918625f82a4cdbaf34ce0f4dcfc342492b5b3086296589ef650f942ca000772a033d796f7f7e949b20cc52c45deda55ae56cafe6
+  metadata.gz: 99b491f10a169e0aeac7fef944d969b48bfa8520a220f3705f4762e3643515dd9e978bef2f5d519abc3970dc29ca734d41d5d6532beb61157389a92aee562ff2
+  data.tar.gz: b806779564f476de930e152265f2b36a340bd0a1dc82a7d703d8a3789f162910991a2a50d26a5c9b5ae9da719ba9b61032d9b4c58eec6ab5360305213547a700

data/lib/pindo/client/httpclient.rb

@@ -3,13 +3,80 @@ require 'uri'
 require 'json'
 require 'faraday'
 require 'pindo/base/aeshelper'
-require 'faraday/retry'
+require 'typhoeus'
+require 'typhoeus/adapters/faraday'
 
 module Pindo
- 
 
-  class HttpClient
+  # 简单的 Faraday 重试中间件（替代 faraday-retry）
+  class SimpleRetryMiddleware < Faraday::Middleware
+    # 默认幂等的 HTTP 方法（可安全重试）
+    IDEMPOTENT_METHODS = [:get, :head, :put, :delete, :options, :trace].freeze
+    # 可重试的 HTTP 状态码（5xx 服务器错误）
+    RETRIABLE_STATUS_CODES = (500..599).freeze
+
+    def initialize(app, options = {})
+      super(app)
+      @max = options[:max] || 3  # 最大重试次数（不包括首次尝试）
+      @interval = options[:interval] || 0.5
+      @backoff_factor = options[:backoff_factor] || 2
+      @interval_randomness = options[:interval_randomness] || 0.5
+      @exceptions = options[:exceptions] || [Faraday::TimeoutError, Faraday::ConnectionFailed]
+      @methods = options[:methods] || IDEMPOTENT_METHODS  # 允许重试的 HTTP 方法
+      @retry_statuses = options[:retry_statuses] || RETRIABLE_STATUS_CODES
+    end
+
+    def call(env)
+      retries = 0
+
+      loop do
+        begin
+          response = @app.call(env)
+
+          # 检查 HTTP 状态码是否需要重试（5xx 错误）
+          # 同时必须满足幂等性要求，避免非幂等请求（如 POST）被意外重试
+          if retriable_response?(response) && retriable_request?(env) && retries < @max
+            retries += 1
+            sleep_with_jitter(retries)
+            next  # 继续下一次循环（重试）
+          end
+
+          return response  # 成功，返回响应
+
+        rescue *@exceptions => e
+          # 检查是否为幂等方法，非幂等方法不自动重试
+          if retriable_request?(env) && retries < @max
+            retries += 1
+            sleep_with_jitter(retries)
+            next  # 继续下一次循环（重试）
+          else
+            raise e  # 不能重试，抛出异常
+          end
+        end
+      end
+    end
+
+    private
 
+    # 检查请求是否可重试（幂等性检查）
+    def retriable_request?(env)
+      @methods.include?(env[:method])
+    end
+
+    # 检查响应是否需要重试（5xx 状态码）
+    def retriable_response?(response)
+      @retry_statuses.include?(response.status)
+    end
+
+    # 指数退避 + 随机抖动
+    def sleep_with_jitter(retry_count)
+      sleep_time = @interval * (@backoff_factor ** (retry_count - 1))
+      jitter = rand * sleep_time * @interval_randomness
+      sleep(sleep_time + jitter)
+    end
+  end
+
+  class HttpClient
 
       attr_accessor :token
       attr_accessor :baseurl
@@ -25,23 +92,32 @@ module Pindo
           }
 
           retry_options = {
-            max: 3,                   # Retry a failed request up to 5 times
-            interval: 0.5,            # First retry after 0.5s
-            backoff_factor: 2,        # Double the delay for each subsequent retry
-            interval_randomness: 0.5, # Specify "jitter" of up to 50% of interval
+            max: 3,
+            interval: 0.5,
+            backoff_factor: 2,
+            interval_randomness: 0.5
           }
 
           con = Faraday.new do |config|
-            config.request :retry, retry_options
-            config.proxy = proxy_options.compact if proxy_options[:uri]  
+            # 使用自定义重试中间件
+            config.use SimpleRetryMiddleware, retry_options
+            # 使用 Typhoeus 适配器（支持代理和连接池）
+            config.adapter :typhoeus
+            config.proxy = proxy_options.compact if proxy_options[:uri]
           end
-          
+
           con
       end
 
       def self.create_instance()
-          
-          con = Faraday.new 
+
+          con = Faraday.new do |config|
+            # 使用自定义重试中间件
+            config.use SimpleRetryMiddleware, max: 3, interval: 0.5, backoff_factor: 2
+            # 使用 Typhoeus 适配器
+            config.adapter :typhoeus
+          end
+
           con
       end
 

data/lib/pindo/command/jps/bind.rb

@@ -1,191 +1,354 @@
-require 'highline/import'
-require 'fileutils'
-require 'json'
+require 'pindo/module/pgyer/pgyerhelper'
+require 'pindo/module/task/task_manager'
+require 'pindo/module/task/model/jps/jps_bind_package_task'
+require 'pindo/options/options'
+require 'pindo/options/groups/task_options'
 
 module Pindo
     class Command
         class Jps < Command
             class Bind < Jps
 
-                self.summary = '将编译的包与工作流绑定'
+                self.summary = '绑定 Git commit 到已上传的项目包'
 
                 self.description = <<-DESC
-将编译的包与工作流绑定。
+                    绑定 Git commit 到已上传的 JPS 项目包。
 
-支持功能:
+                    支持功能:
 
-    * 绑定编译包到指定工作流
+                        * 交互式选择包类型（IPA、APK、WebGL、macOS）
+                        * 支持多选，一次绑定多个包
+                        * 支持选择历史 commit（使用 --select 参数）
+                        * 自动关联到当前 HEAD commit 记录
 
-    * 管理包与工作流的关联关系
+                    使用示例:
 
-    * 支持多个工作流配置
+                        $ pindo jps bind                                # 交互式选择包类型和 commit
 
-    * 自动验证绑定状态
+                        $ pindo jps bind --proj=demo                    # 指定项目
 
-使用示例:
+                        $ pindo jps bind --select                       # 选择历史 commit
 
-    $ pindo jps bind                        # 绑定当前目录的包到默认工作流
-
-    $ pindo jps bind --proj=demo            # 绑定指定项目到工作流
-
-    $ pindo jps bind --workflow=release     # 绑定到指定的工作流
-
-    $ pindo jps bind --list                 # 列出所有可用的工作流
                 DESC
 
                 self.arguments = [
-
                 ]
 
+                # 定义此命令使用的参数项
+                def self.option_items
+                  @option_items ||= Pindo::Options::OptionGroup.merge(
+                    Pindo::Options::JPSOptions.select(:proj),
+                    Pindo::Options::TaskOptions.select(:select),
+                    Pindo::Options::GitOptions.all
+                  )
+                end
+
                 def self.options
-                  [
-                    ['--proj', '指定要绑定的项目名称'],
-                    ['--workflow', '指定要绑定的工作流名称'],
-                    ['--list', '列出所有可用的工作流'],
-                    ['--unbind', '解除包与工作流的绑定'],
-                    ['--status', '查看当前绑定状态']
-                  ].concat(super)
+                  option_items.map(&:to_claide_option).concat(super)
                 end
 
                 def initialize(argv)
-                    @args_proj_name = argv.option('proj')
-                    @args_workflow_name = argv.option('workflow')
-                    @args_list_flag = argv.flag?('list', false)
-                    @args_unbind_flag = argv.flag?('unbind', false)
-                    @args_status_flag = argv.flag?('status', false)
+                    # 使用 Options 系统解析参数
+                    @options = initialize_options(argv)
 
-                    super
-                    @additional_args = argv.remainder!
+                    # JPS 参数
+                    @args_proj_name = @options[:proj]
+
+                    # Task 参数
+                    @args_select_flag = @options[:select] || false
+
+                    super(argv)
                 end
 
                 def validate!
                     super
-                    if @args_list_flag || @args_status_flag
-                        # 列出或查看状态时不需要其他参数
+                end
+
+                def run
+                    project_path = Dir.pwd
+
+                    # 1. 如果启用 --select 参数，获取用户选择的 commit
+                    selected_commit_info = nil
+                    if @args_select_flag
+                        selected_commit_info = select_git_commit(project_path)
+
+                        if selected_commit_info.nil?
+                            puts "未选择任何提交，已取消操作"
+                            return
+                        end
+
+                        puts "\n已选择提交:"
+                        puts "  Commit ID: #{selected_commit_info[:commit_id][0..7]}"
+                        puts "  时间: #{selected_commit_info[:commit_time]}"
+                        puts "  描述: #{selected_commit_info[:commit_desc]}"
+                        puts ""
+                    end
+
+                    # 2. 获取 JPS 配置（git workflow 信息）
+                    pgyer_helper = PgyerHelper.share_instace
+                    pgyer_helper.login
+
+                    app_info_obj, git_workflow_info = pgyer_helper.prepare_upload(
+                        working_directory: project_path,
+                        proj_name: @args_proj_name,
+                        package_type: "",
+                        manage_type: "git"
+                    )
+
+                    if app_info_obj.nil?
+                        raise Informative, "#{@args_proj_name} 错误，请输入正确的App代号名称"
+                    end
+
+                    project_id = app_info_obj["id"]
+
+                    # 3. 让用户选择要绑定的包类型
+                    selected_package_types = select_package_types
+                    if selected_package_types.empty?
+                        puts "未选择任何包类型，已取消操作"
                         return
                     end
 
-                    if @args_unbind_flag && @args_workflow_name.nil?
-                        help! '解除绑定时需要指定工作流名称'
+                    # 4. 获取对应类型的最新包
+                    app_version_list = get_latest_packages_by_types(pgyer_helper, project_id, selected_package_types)
+
+                    if app_version_list.empty?
+                        raise Informative, "未找到可绑定的项目包，请先上传包"
                     end
-                end
 
-                def run
-                    if @args_list_flag
-                        list_workflows
-                    elsif @args_status_flag
-                        show_bind_status
-                    elsif @args_unbind_flag
-                        unbind_workflow
+                    puts "\n找到以下项目包:"
+                    app_version_list.each do |pkg|
+                        puts "  [#{pkg['nativePackageType']}] ID: #{pkg['id']}, Version: #{pkg['projectVersion']}, Build: #{pkg['build']}"
+                    end
+                    puts ""
+
+                    # 5. 创建任务链
+                    tasks = []
+
+                    # Git 提交任务
+                    process_type = Pindo::GitHandler.get_uncommitted_files_process_type(
+                        project_dir: project_path,
+                        interactive: true
+                    )
+
+                    git_commit_task = Pindo::TaskSystem::GitCommitTask.new(
+                        project_path,
+                        {
+                            process_type: process_type,
+                            commit_message: "build: jps bind 绑定前提交"
+                        }
+                    )
+                    tasks << git_commit_task
+
+                    # 创建绑定任务（一次绑定所有包）
+                    bind_task = Pindo::TaskSystem::JPSBindPackageTask.new(
+                        app_version_list,  # 传入包列表
+                        {
+                            git_commit_id: selected_commit_info&.dig(:commit_id),
+                            git_commit_time: selected_commit_info&.dig(:commit_time),
+                            git_commit_desc: selected_commit_info&.dig(:commit_desc),
+                            project_dir: project_path,
+                            app_info_obj: app_info_obj,
+                            workflow_info: git_workflow_info,
+                            project_name: @args_proj_name
+                        }
+                    )
+                    bind_task.dependencies << git_commit_task.id
+                    tasks << bind_task
+
+                    # 6. 执行任务
+                    task_manager = Pindo::TaskSystem::TaskManager.instance
+                    task_manager.clear_all
+                    tasks.each { |task| task_manager.add_task(task) }
+                    task_manager.start
+
+                    # 7. 输出结果
+                    report = task_manager.execution_report
+                    if report[:success] > 0
+                        puts "\n✅ 绑定完成! 成功绑定 #{app_version_list.size} 个包到 Git Workflow"
                     else
-                        bind_to_workflow
+                        raise Informative, "绑定失败"
                     end
                 end
 
                 private
 
-                def list_workflows
-                    puts "\n可用的工作流列表："
-                    puts "─────────────────────────────"
-
-                    # TODO: 从配置或API获取工作流列表
-                    workflows = [
-                        { name: "dev", description: "开发环境工作流" },
-                        { name: "test", description: "测试环境工作流" },
-                        { name: "staging", description: "预发布环境工作流" },
-                        { name: "release", description: "正式发布工作流" }
+                # 交互式选择包类型
+                # @return [Array<String>] 选择的包类型数组
+                def select_package_types
+                    puts "\n请选择要绑定的包类型（可多选）:"
+                    puts "━" * 60
+
+                    package_types = [
+                        { key: 'ipa', name: 'IPA (iOS)' },
+                        { key: 'apk', name: 'APK (Android)' },
+                        { key: 'webgl', name: 'WebGL (Web)' },
+                        { key: 'macos', name: 'MACOS (macOS)' }
                     ]
 
-                    workflows.each do |workflow|
-                        puts "  • #{workflow[:name].ljust(12)} - #{workflow[:description]}"
+                    package_types.each_with_index do |type, index|
+                        puts "  #{index + 1}. #{type[:name]}"
                     end
-                    puts "─────────────────────────────\n"
-                end
+                    puts "  0. 取消操作"
+                    puts "━" * 60
 
-                def show_bind_status
-                    puts "\n当前绑定状态："
-                    puts "─────────────────────────────"
+                    # 获取用户输入
+                    print "\n请输入序号（多个用逗号分隔，如 1,2）: "
+                    input = $stdin.gets.strip
 
-                    # TODO: 从配置或API获取当前绑定状态
-                    proj_name = @args_proj_name || get_current_project_name
+                    # 解析用户输入
+                    if input == '0' || input.empty?
+                        return []
+                    end
 
-                    if proj_name
-                        puts "  项目名称: #{proj_name}"
-                        puts "  绑定状态: 已绑定"
-                        puts "  工作流: release"
-                        puts "  绑定时间: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
-                        puts "  最后构建: #123"
+                    selected = []
+                    input.split(',').each do |num_str|
+                        num = num_str.strip.to_i
+                        if num > 0 && num <= package_types.size
+                            selected << package_types[num - 1][:key]
+                        end
+                    end
+
+                    if selected.empty?
+                        puts "无效输入，未选择任何包类型"
                     else
-                        puts "  当前没有绑定任何工作流"
+                        puts "\n已选择: #{selected.join(', ')}"
                     end
-                    puts "─────────────────────────────\n"
+
+                    selected
                 end
 
-                def bind_to_workflow
-                    proj_name = @args_proj_name || get_current_project_name
-                    workflow_name = @args_workflow_name || "dev"
+                # 根据包类型获取最新的项目包列表
+                # @param pgyer_helper [PgyerHelper] JPS 客户端
+                # @param project_id [String] 项目 ID
+                # @param package_types [Array<String>] 包类型数组
+                # @return [Array<Hash>] 项目包信息列表
+                def get_latest_packages_by_types(pgyer_helper, project_id, package_types)
+                    packages_to_bind = []
+
+                    package_types.each do |package_type|
+                        # 包类型映射：webgl -> zip
+                        native_package_type = case package_type
+                        when 'webgl'
+                            'zip'
+                        else
+                            package_type
+                        end
 
-                    if proj_name.nil? || proj_name.empty?
-                        raise Informative, "无法确定项目名称，请使用 --proj 参数指定"
+                        begin
+                            # 获取项目包列表（只获取第一页的第一条）
+                            result = pgyer_helper.instance_variable_get(:@pgyer_client).get_project_package_list(
+                                projectId: project_id,
+                                params: {
+                                    pageNo: 1,
+                                    pageSize: 1,
+                                    nativePackageType: native_package_type
+                                }
+                            )
+
+                            # 兼容两种响应格式
+                            packages = result&.dig("data") || result&.dig("data", "packages")
+
+                            if packages && packages.is_a?(Array) && packages.any?
+                                pkg = packages.first
+                                # 添加原始类型标记
+                                pkg['originalType'] = package_type
+                                packages_to_bind << pkg
+                            else
+                                puts "  ⚠️  未找到 #{package_type} 类型的包"
+                            end
+                        rescue => e
+                            Funlog.instance.fancyinfo_error("获取 #{package_type} 类型的项目包失败: #{e.message}")
+                        end
                     end
 
-                    puts "\n正在绑定包到工作流..."
-                    puts "  项目: #{proj_name}"
-                    puts "  工作流: #{workflow_name}"
+                    packages_to_bind
+                end
 
-                    # TODO: 调用JPS API进行实际绑定
-                    # result = JpsClient.bind_workflow(
-                    #     project: proj_name,
-                    #     workflow: workflow_name
-                    # )
+                # 交互式选择 git commit
+                # @param project_path [String] 项目路径
+                # @return [Hash, nil] 包含 :commit_id, :commit_time, :commit_desc，或 nil（取消）
+                def select_git_commit(project_path)
+                    # 1. 查找 git 根目录
+                    git_root = Pindo::GitHandler.git_root_directory(local_repo_dir: project_path)
+                    unless git_root
+                        raise Informative, "当前目录不是 git 仓库"
+                    end
 
-                    puts "\n✅ 绑定成功！"
-                    puts "  包 '#{proj_name}' 已成功绑定到工作流 '#{workflow_name}'"
-                    puts "  下次构建将自动触发该工作流"
-                end
+                    # 2. 获取最近 15 条 commit 历史
+                    all_commits = get_recent_commits(git_root, limit: 15)
+
+                    if all_commits.empty?
+                        raise Informative, "未找到 git commit 历史"
+                    end
+
+                    # 3. 筛选符合规范的提交（以 feat:, fix: 等开头）
+                    valid_prefixes = ['feat:', 'fix:', 'docs:', 'style:', 'refactor:', 'perf:', 'test:', 'build:', 'ci:', 'chore:', 'revert:']
+                    commits = all_commits.select do |commit|
+                        desc = commit[:commit_desc].to_s.strip
+                        valid_prefixes.any? { |prefix| desc.downcase.start_with?(prefix) }
+                    end
 
-                def unbind_workflow
-                    proj_name = @args_proj_name || get_current_project_name
-                    workflow_name = @args_workflow_name
+                    # 如果没有符合规范的提交，提示用户并使用全部提交
+                    if commits.empty?
+                        puts "\n警告：在最近15个提交中未找到符合规范的提交（feat:, fix: 等开头）"
+                        puts "显示所有提交供您选择："
+                        commits = all_commits
+                    else
+                        puts "\n从最近15个提交中筛选出 #{commits.size} 个符合规范的提交："
+                    end
 
-                    if proj_name.nil? || proj_name.empty?
-                        raise Informative, "无法确定项目名称，请使用 --proj 参数指定"
+                    # 4. 显示 commit 列表
+                    puts "\n请选择要绑定的 git 提交:"
+                    puts "━" * 80
+                    commits.each_with_index do |commit, index|
+                        puts "#{index + 1}. [#{commit[:commit_id][0..7]}] #{commit[:commit_time]} - #{commit[:commit_desc]}"
                     end
+                    puts "0. 取消操作"
+                    puts "━" * 80
+
+                    # 5. 获取用户选择
+                    choice = nil
+                    loop do
+                        print "\n请输入序号 (0-#{commits.size}): "
+                        input = $stdin.gets.strip
 
-                    puts "\n正在解除绑定..."
-                    puts "  项目: #{proj_name}"
-                    puts "  工作流: #{workflow_name}"
+                        choice = input.to_i
+                        break if choice >= 0 && choice <= commits.size
 
-                    # TODO: 调用JPS API进行解除绑定
-                    # result = JpsClient.unbind_workflow(
-                    #     project: proj_name,
-                    #     workflow: workflow_name
-                    # )
+                        puts "无效输入，请输入 0-#{commits.size} 之间的数字"
+                    end
 
-                    puts "\n✅ 解除绑定成功！"
-                    puts "  包 '#{proj_name}' 已从工作流 '#{workflow_name}' 解除绑定"
+                    # 6. 返回选择的 commit（0 表示取消）
+                    choice == 0 ? nil : commits[choice - 1]
                 end
 
-                def get_current_project_name
-                    # 尝试从当前目录获取项目名称
-                    current_dir = Dir.pwd
-
-                    # 1. 尝试从git仓库名获取
-                    if File.directory?(File.join(current_dir, ".git"))
-                        git_config = File.join(current_dir, ".git", "config")
-                        if File.exist?(git_config)
-                            config_content = File.read(git_config)
-                            if config_content =~ /url = .*[\/:]([^\/]+?)(?:\.git)?$/
-                                return $1
-                            end
+                # 获取最近的 git commits
+                # @param git_root [String] git 根目录
+                # @param limit [Integer] 获取的 commit 数量
+                # @return [Array<Hash>] commit 列表，每个元素包含 :commit_id, :commit_time, :commit_desc
+                def get_recent_commits(git_root, limit: 20)
+                    Dir.chdir(git_root) do
+                        # 使用 git log 获取 commit 历史
+                        # 格式：commit_id|commit_time|commit_desc
+                        output = `git log -#{limit} --format="%H|%ci|%s" 2>/dev/null`.strip
+
+                        return [] if output.empty?
+
+                        output.split("\n").map do |line|
+                            parts = line.split('|', 3)
+                            {
+                                commit_id: parts[0],
+                                commit_time: parts[1],
+                                commit_desc: parts[2]
+                            }
                         end
                     end
-
-                    # 2. 尝试从目录名获取
-                    File.basename(current_dir)
+                rescue => e
+                    Funlog.instance.fancyinfo_error("获取 git commit 历史失败: #{e.message}")
+                    []
                 end
 
             end
         end
     end
-end
+end

data/lib/pindo/command/jps/media.rb

@@ -174,7 +174,7 @@ module Pindo
                 # @return [Hash, nil] 包含 :commit_id, :commit_time, :commit_desc，或 nil（取消）
                 def select_git_commit(project_path)
                     # 1. 查找 git 根目录
-                    git_root = find_git_root(project_path)
+                    git_root = Pindo::GitHandler.git_root_directory(local_repo_dir: project_path)
                     unless git_root
                         raise Informative, "当前目录不是 git 仓库"
                     end
@@ -227,20 +227,6 @@ module Pindo
                     choice == 0 ? nil : commits[choice - 1]
                 end
 
-                # 查找 git 根目录
-                # @param path [String] 起始路径
-                # @return [String, nil] git 根目录，未找到返回 nil
-                def find_git_root(path)
-                    current = File.expand_path(path)
-                    while current != '/'
-                        if File.exist?(File.join(current, '.git'))
-                            return current
-                        end
-                        current = File.dirname(current)
-                    end
-                    nil
-                end
-
                 # 获取最近的 git commits
                 # @param git_root [String] git 根目录
                 # @param limit [Integer] 获取的 commit 数量