pindo 5.21.5 → 5.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4ccbec1218f28dfa10b000e89759db3e8167c0ea598637a0f8436a557ab14bc
-  data.tar.gz: 737550673bf62315c4ab30652496a82bcda55001991af18c2c5da1b019b9cf83
+  metadata.gz: 683bf46a8095e20c20a6fdc339b99a6ae83337dc58431b67fb6b1d00263e42a8
+  data.tar.gz: 291caf87a1647dc8af05b26fbbfa94cd588385177869e43ec5983db3e90233f8
 SHA512:
-  metadata.gz: 52e831191efa0d0092fdd2333658ece13ff82f004255d5dfe55b5f75a295b5d46356fc56956323b8b526bd6dfdda5fa10b15e5e144e971fb70bd629bb5268e57
-  data.tar.gz: 6fa3ad96ffe7951bcec719e8c9a3ffad2540e807c4d451ba6a3dc16fbe59e85a2520f874d72ae589b72ebd47828df71c0482dfcedbdb310e58d6c99f49e24efb
+  metadata.gz: 1d0176e844e360885e6bf90ebd9024b1982ee7c519ce6d01f3fe994e085110b12107f34271d379283ca4ca27165e0cb1d2187a1daf4cfcbc2ce65b3445688786
+  data.tar.gz: 5a94ae4f340b1cc924a0e85e1c0a57272014d58c7498d248f91ab5d3d6bba399f2d3521c1d6d90dec2d5b5fdb578d4d05b1ce02b3bf55fd7ecc3eb90837a4e64

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

@@ -10,31 +10,31 @@ module Pindo
         class Jps < Command
             class Config < Jps
 
-                self.summary = '配置当前工程与 JPS 项目及工作流的绑定'
+                self.summary = '配置当前工程与 JPS 项目及安装包工具 / Git 工作流的绑定'
 
                 self.description = <<-DESC
-                    将当前工程绑定到 JPS 项目及其一个或多个工作流，并写入 JPSBuildConfig.json。
+                    将当前工程绑定到 JPS 项目的安装包工具（ipa/apk/zip/mac/exe）和 Git 工作流，并写入 JPSBuildConfig.json。
 
                     只做配置绑定，不编译、不上传，产出与 pindo ios/and autobuild 一致的配置文件。
 
                     支持功能:
 
-                        * 选一次 JPS 项目，一次配置多个工作流类型
+                        * 选一次 JPS 项目，一次配置多个类型
                         * 交互多选菜单，或用 --type 非交互指定类型
                         * --proj 直接指定项目名，跳过项目选择菜单（非交互场景）
-                        * --workflow_name 按名称指定工作流，用于同类型多工作流消歧（非交互场景）
+                        * --workflow_name 按名称指定 Git 工作流或安装包工具，用于同类型多个时消歧（非交互场景）
                         * 支持类型: ipa、apk、zip(WebGL)、mac(macOS)、exe(Windows)、git
-                        * --clean 清除已绑定的工作流或整个配置文件
+                        * --clean 清除已绑定的工具 / 工作流或整个配置文件
 
                     使用示例:
 
-                        $ pindo jps config                              # 交互选择项目和工作流类型
+                        $ pindo jps config                              # 交互选择项目和绑定类型
 
                         $ pindo jps config --type=ipa,apk,git           # 非交互配置指定类型（项目仍需交互选）
 
                         $ pindo jps config --proj=MyApp --type=ipa,git  # 全程非交互（agent/CI 适用）
 
-                        $ pindo jps config --clean                      # 交互清除已绑定的工作流
+                        $ pindo jps config --clean                      # 交互清除已绑定的工具 / 工作流
 
                         $ pindo jps config --clean --type=ipa           # 清除指定类型的绑定
 
@@ -96,7 +96,7 @@ module Pindo
 
                     selected_types = resolve_selected_types
                     if selected_types.empty?
-                        puts "未选择任何工作流类型，已取消操作"
+                        puts "未选择任何绑定类型，已取消操作"
                         return
                     end
 
@@ -110,9 +110,9 @@ module Pindo
                         raise Informative, "未找到 JPS 项目，请检查项目名称或配置文件"
                     end
 
-                    # Phase 1: 先选定所有类型的工作流（任一歧义/缺失即报错，此时尚未写任何文件）
+                    # Phase 1: 先选定所有类型的工具 / 工作流（任一歧义/缺失即报错，此时尚未写任何文件）
                     selections = selected_types.map do |type|
-                        puts "\n选择工作流: #{type[:name]}"
+                        puts "\n选择#{binding_label(type)}: #{type[:name]}"
                         workflow_info = pgyer_helper.select_workflow_for_project(
                             project_id: app_info_obj["id"],
                             package_type: type[:package_type],
@@ -169,7 +169,7 @@ module Pindo
                 end
 
                 def select_types_interactive
-                    puts "\n请选择要配置的工作流类型（可多选）:"
+                    puts "\n请选择要配置的绑定类型（安装包为工具，git 为工作流，可多选）:"
                     puts DIVIDER
                     WORKFLOW_TYPES.each_with_index do |type, index|
                         puts "  #{index + 1}. #{type[:name]}"
@@ -343,11 +343,20 @@ module Pindo
                     WORKFLOW_TYPES.each do |type|
                         workflow = config[type[:workflow_key]]
                         next if workflow.nil?
-                        puts "  #{type[:name]}: #{workflow['tab_name']} (ID: #{workflow['workflow_id']})"
+                        if type[:manage_type] == 'git'
+                            puts "  #{type[:name]}: 工作流: #{workflow['tab_name']} (ID: #{workflow['workflow_id']})"
+                        else
+                            puts "  #{type[:name]}: 工具: #{workflow['tab_name']} (packageId: #{workflow['package_id']})"
+                        end
                     end
                     puts DIVIDER
                 end
 
+                # 安装包类型绑定的是「工具」，Git 绑定的是「工作流」
+                def binding_label(type)
+                    type[:manage_type] == 'git' ? '工作流' : '工具'
+                end
+
             end
         end
     end

data/lib/pindo/module/pgyer/pgyerhelper.rb

@@ -156,6 +156,7 @@ module Pindo
           # 7. 所有验证通过
           result[:valid] = true
           result[:workflow_info] = {
+            package_id: workflow['package_id'].to_s,
             workflow_id: workflow['workflow_id'],
             tab_name: workflow['tab_name'],
             package_name: workflow['package_name'],
@@ -166,6 +167,7 @@ module Pindo
           if ENV['PINDO_DEBUG']
             puts "[PINDO_DEBUG] ✓✓✓ 配置验证通过 (#{workflow_key})"
             puts "[PINDO_DEBUG] 返回 valid=true，workflow_info:"
+            puts "  package_id: #{result[:workflow_info][:package_id]}"
             puts "  workflow_id: #{result[:workflow_info][:workflow_id]}"
             puts "  tab_name: #{result[:workflow_info][:tab_name]}"
             puts "  manage_type: #{result[:workflow_info][:manage_type]}"
@@ -174,86 +176,44 @@ module Pindo
           return result
         end
 
-        # 为项目选择工作流
+        # 为项目选择工作流（Git）或安装包工具（ipa/apk/zip/mac/exe）
+        #
+        # JPS V1.3.94 起，workflow/list 不再返回产物工作流；安装包入口改为项目的 packageTools，
+        # 因此非 git 类型一律从 project/detail 的 packageTools 中选择。
         #
         # @param project_id [String] 项目ID
         # @param package_type [String] 包类型
         # @param working_directory [String] 工作目录
-        # @param manage_type [String] 管理类型（默认为空，"git" 时筛选 git 工作流）
-        # @return [Hash] 选择的工作流信息
+        # @param manage_type [String] 管理类型（默认为空，"git" 时选择 Git 工作流）
+        # @param workflow_name [String, nil] 按名称精确选择（Git 匹配 tabName；工具匹配 name、subtitle 或 name（subtitle））
+        # @return [Hash] 选择的工作流/工具信息（symbol key 结构）
         def select_workflow_for_project(project_id:, package_type:, working_directory:, manage_type: "", workflow_name: nil)
-          # 1. 从 JPS API 获取可用工作流列表
+          if manage_type == "git"
+            return select_git_workflow_for_project(project_id: project_id, package_type: package_type, workflow_name: workflow_name)
+          end
+
+          select_package_tool_for_project(project_id: project_id, package_type: package_type, workflow_name: workflow_name)
+        end
+
+        # 选择 Git 仓库工作流（仍通过 workflow/list 获取）
+        def select_git_workflow_for_project(project_id:, package_type: nil, workflow_name: nil)
           Funlog.instance.fancyinfo_start("正在获取可用工作流...")
 
           workflow_result = @pgyer_client.get_project_workflows(project_id: project_id)
-
           if workflow_result.nil? || workflow_result['data'].nil?
             raise Informative, "获取工作流列表失败"
           end
 
           workflows = workflow_result['data']
-
-          if workflows.empty?
-            raise Informative, "该项目没有可用的工作流"
+          type_desc = 'Git 管理类型'
+          # 严格筛选 manage_type == "git"，不降级到其它类型
+          display_workflows = workflows.select do |w|
+            (w['manageType'] == 'git') || (w['manage_type'] == 'git')
           end
 
-          puts "package_type #{package_type} manage_type: #{manage_type}"
-
-          # 2. 根据 manage_type 或 package_type 过滤工作流
-          if manage_type == "git"
-            # manage_type 为 git 时，只筛选 manage_type == "git" 的工作流，不看 package_type
-            # 严格筛选，不包括 manage_type 为空或其他类型的工作流
-            filtered_workflows = workflows.select do |w|
-              (w['manageType'] == 'git') || (w['manage_type'] == 'git')
-            end
-            type_desc = 'Git 管理类型'
-            # manage_type == "git" 时严格使用筛选结果，不降级
-            display_workflows = filtered_workflows
-          else
-            # 按 package_type 过滤工作流
-            filtered_workflows = workflows.select do |w|
-              # 如果工作流有 packageType 字段，进行过滤
-              if w['packageType']
-                case package_type
-                when 'ipa'
-                  w['packageType'] == 'ipa'
-                when 'apk'
-                  w['packageType'] == 'apk'
-                when 'zip'
-                  w['packageType'] == 'zip'
-                when 'mac'
-                  w['packageType'] == 'mac'
-                when 'exe'
-                  w['packageType'] == 'exe'
-                else
-                  true
-                end
-              else
-                # 如果没有 packageType 字段，显示所有工作流
-                true
-              end
-            end
-
-            type_desc = case package_type
-              when 'ipa' then 'iOS IPA'
-              when 'apk' then 'Android APK'
-              when 'zip' then 'WebGL'
-              when 'mac' then 'macOS App'
-              when 'exe' then 'Windows EXE'
-              else package_type
-            end
-
-            # 非 git 模式：过滤结果即为候选。若为空则交由下方“没有找到匹配工作流”报错，
-            # 不再回退到全部工作流——否则会把其它类型的工作流误当作请求类型（写错 workflow_key）
-            display_workflows = filtered_workflows
-          end
-
-          # 过滤后再报数：只报总数会让人以为剩下的工作流被漏掉了，
-          # 实际是按 manage_type / package_type 筛掉的，两个数字一起给出才不歧义
           Funlog.instance.fancyinfo_success("获取工作流列表成功，共 #{workflows.size} 个工作流，其中 #{type_desc} #{display_workflows.size} 个")
 
-          # 2.5 若指定了 workflow_name，按名称精确匹配（忽略大小写与首尾空格）确定性选择。
-          # 只接受完整精确匹配，不做子串模糊匹配，避免 "Production" 误命中 "Legacy Production Upload"。
+          # 指定 workflow_name 时只接受完整精确匹配（忽略大小写与首尾空格），不做子串模糊匹配
           if workflow_name && !workflow_name.to_s.strip.empty? && !display_workflows.empty?
             key_name = workflow_name.to_s.strip.downcase
             name_matched = display_workflows.select do |w|
@@ -266,44 +226,23 @@ module Pindo
             display_workflows = name_matched
           end
 
-          # 3. 根据匹配数量决定选择方式
-          workflow = nil
-
           if display_workflows.empty?
-            # 情况1: 没有匹配的工作流
-            error_msg = if manage_type == "git"
-              "没有找到匹配 #{type_desc} 的工作流，请在 JPS 后台创建 Git 类型工作流（项目ID: #{project_id}）"
-            else
-              "没有找到匹配 #{type_desc} 的工作流，请在 JPS 后台配置（项目ID: #{project_id}）"
-            end
-            raise Informative, error_msg
-
-          elsif display_workflows.size == 1
-            # 情况2: 只有1个匹配的工作流，自动选择
-            workflow = display_workflows.first
-            workflow_name = workflow['tabName'] || workflow['tab_name']
-            Funlog.instance.fancyinfo_success("自动选择唯一匹配的工作流: #{workflow_name}")
+            raise Informative, "没有找到匹配 #{type_desc} 的工作流，请在 JPS 后台创建 Git 类型工作流（项目ID: #{project_id}）"
+          end
 
+          workflow = if display_workflows.size == 1
+            Funlog.instance.fancyinfo_success("自动选择唯一匹配的工作流: #{display_workflows.first['tabName'] || display_workflows.first['tab_name']}")
+            display_workflows.first
           else
-            # 情况3: 有多个匹配的工作流，让用户选择
-            cli = HighLine.new
-            workflow_choices = display_workflows.map do |w|
+            choices = display_workflows.map do |w|
               "#{w['tabName'] || w['tab_name']} (ID: #{w['id'] || w['workflow_id']})"
             end
-
-            selected = cli.choose do |menu|
-              menu.prompt = "请选择 #{type_desc} 工作流:"
-              menu.choices(*workflow_choices)
-            end
-
-            # 提取选择的工作流
-            selected_index = workflow_choices.index(selected)
-            workflow = display_workflows[selected_index]
+            choose_from_menu(prompt: "请选择 #{type_desc} 工作流:", choices: choices, items: display_workflows)
           end
 
-          # 4. 返回标准化的工作流信息
           {
             workflow_id: workflow['id'] || workflow['workflow_id'],
+            package_id: "",
             tab_name: workflow['tabName'] || workflow['tab_name'],
             package_name: workflow['packageName'] || workflow['package_name'] || workflow['tabName'] || workflow['tab_name'],
             package_type: package_type,
@@ -311,96 +250,73 @@ module Pindo
           }
         end
 
-        # AdHoc 专用工作流选择
-        # 筛选条件：
-        #   1. package_type 匹配
-        #   2. tab_name 必须包含 "提交包"
-        #
-        # @param project_id [String] 项目ID
-        # @param package_type [String] 包类型（ipa/apk/zip/app）
-        # @return [Hash] 选择的工作流信息
-        def select_workflow_for_adhoc(project_id:, package_type:)
-          # 1. 从 JPS API 获取可用工作流列表
-          workflow_result = @pgyer_client.get_project_workflows(project_id: project_id)
+        # 选择安装包工具（来自 project/detail 的 packageTools）
+        def select_package_tool_for_project(project_id:, package_type:, workflow_name: nil)
+          Funlog.instance.fancyinfo_start("正在获取项目工具列表...")
 
-          if workflow_result.nil? || workflow_result['data'].nil?
-            raise Informative, "获取工作流列表失败"
-          end
+          tools = get_project_package_tools(project_id: project_id, package_type: package_type)
+          type_desc = package_type_desc(package_type)
 
-          workflows = workflow_result['data']
+          Funlog.instance.fancyinfo_success("获取工具列表成功，#{type_desc} 工具共 #{tools.size} 个")
 
-          if workflows.empty?
-            raise Informative, "该项目没有可用的工作流"
+          if workflow_name && !workflow_name.to_s.strip.empty? && !tools.empty?
+            tools = match_package_tools_by_name(tools: tools, name: workflow_name, type_desc: type_desc)
           end
 
-          # 2. 第一层过滤：根据 package_type
-          filtered_by_type = workflows.select do |w|
-            if w['packageType']
-              case package_type
-              when 'ipa'
-                w['packageType'] == 'ipa'
-              when 'apk'
-                w['packageType'] == 'apk'
-              when 'zip'
-                w['packageType'] == 'zip'
-              when 'mac'
-                w['packageType'] == 'mac'
-              else
-                true
-              end
-            else
-              # 如果没有 packageType 字段，保留（后续通过名称筛选）
-              true
-            end
-          end
-
-          # 3. 第二层过滤：tab_name 必须包含 "提交包"
-          adhoc_workflows = filtered_by_type.select do |w|
-            tab_name = w['tabName'] || w['tab_name'] || ''
-            tab_name.include?('提交包')
+          if tools.empty?
+            raise Informative, "项目中没有可用的 #{type_desc} 工具，请到 JPS 项目的「工具」页新建（项目ID: #{project_id}）"
           end
 
-          if adhoc_workflows.empty?
-            raise Informative, "未找到符合条件的 AdHoc 工作流\n" \
-                                "要求：package_type=#{package_type} 且 tab_name 包含 '提交包'\n" \
-                                "请检查 JPS 工作流配置"
+          tool = if tools.size == 1
+            Funlog.instance.fancyinfo_success("自动选择唯一匹配的工具: #{package_tool_display_name(tools.first)}")
+            tools.first
+          else
+            choices = tools.map { |t| "#{package_tool_display_name(t)} (版本数: #{t['packageCount'] || 0})" }
+            choose_from_menu(prompt: "请选择 #{type_desc} 工具:", choices: choices, items: tools)
           end
 
-          # 4. 根据匹配数量决定选择方式
-          workflow = nil
+          package_tool_to_workflow_info(tool, package_type)
+        end
 
-          if adhoc_workflows.size == 1
-            # 只有 1 个匹配，自动选择
-            workflow = adhoc_workflows.first
-          else
-            # 有多个匹配，让用户选择
-            require 'highline/import'
-            cli = HighLine.new
+        # 按名称精确匹配工具（忽略大小写与首尾空格）：显示名 name（subtitle）、subtitle（原 tab 名）、name 任一相等
+        def match_package_tools_by_name(tools:, name:, type_desc:)
+          key = name.to_s.strip.downcase
+          matched = tools.select do |t|
+            [package_tool_display_name(t), t["subtitle"], t["name"]].any? { |v| v.to_s.strip.downcase == key }
+          end
+          if matched.empty?
+            available = tools.map { |t| package_tool_display_name(t) }.join('、')
+            raise Informative, "未找到名称精确匹配 \"#{name}\" 的 #{type_desc} 工具，可选: #{available}"
+          end
+          matched
+        end
 
-            workflow_choices = adhoc_workflows.map do |w|
-              tab_name = w['tabName'] || w['tab_name']
-              workflow_id = w['id'] || w['workflow_id']
-              "#{tab_name} (ID: #{workflow_id})"
-            end
+        # AdHoc 专用工具选择
+        # 筛选条件：packageType 匹配，且副标题（原 tab 名）或名称包含 "提交包"
+        #
+        # @param project_id [String] 项目ID
+        # @param package_type [String] 包类型（ipa/apk/zip/mac）
+        # @return [Hash] 选择的工具信息
+        def select_workflow_for_adhoc(project_id:, package_type:)
+          tools = get_project_package_tools(project_id: project_id, package_type: package_type)
+          adhoc_tools = tools.select do |t|
+            t["subtitle"].to_s.include?('提交包') || t["name"].to_s.include?('提交包')
+          end
 
-            selected = cli.choose do |menu|
-              menu.prompt = "请选择 AdHoc 工作流:"
-              menu.choices(*workflow_choices)
-            end
+          if adhoc_tools.empty?
+            raise Informative, "未找到符合条件的 AdHoc 工具\n" \
+                                "要求：packageType=#{package_type} 且副标题包含 '提交包'\n" \
+                                "请到 JPS 项目的「工具」页检查"
+          end
 
-            # 提取选择的工作流
-            selected_index = workflow_choices.index(selected)
-            workflow = adhoc_workflows[selected_index]
+          tool = if adhoc_tools.size == 1
+            adhoc_tools.first
+          else
+            choices = adhoc_tools.map { |t| package_tool_display_name(t) }
+            choose_from_menu(prompt: "请选择 AdHoc 工具:", choices: choices, items: adhoc_tools)
           end
 
-          # 5. 返回标准化的工作流信息
-          {
-            workflow_id: workflow['id'] || workflow['workflow_id'],
-            tab_name: workflow['tabName'] || workflow['tab_name'],
-            package_type: workflow['packageType'] || package_type,
-            package_name: workflow['packageName'] || workflow['package_name'] || '',
-            manage_type: workflow['manageType'] || workflow['manage_type'] || ''
-          }
+          package_tool_to_workflow_info(tool, package_type)
         end
 
         # 获取 AdHoc 上传信息
@@ -463,19 +379,19 @@ module Pindo
             raise Informative, "未找到项目: #{upload_proj_name}，请检查项目名称是否正确"
           end
 
-          # 4. 获取 AdHoc 工作流（调用专用函数）
+          # 4. 获取 AdHoc 工具（调用专用函数）
           workflow_info = select_workflow_for_adhoc(
             project_id: app_info_obj["id"],
             package_type: package_type
           )
 
           unless workflow_info
-            raise Informative, "未能获取 AdHoc 工作流信息"
+            raise Informative, "未能获取 AdHoc 工具信息"
           end
 
-          # 5. 输出最终选择的项目和工作流
+          # 5. 输出最终选择的项目和工具
           puts "\n✓ 项目: #{app_info_obj['projectName']}"
-          puts "✓ 工作流: #{workflow_info[:tab_name]}"
+          puts "✓ 工具: #{workflow_info[:tab_name]}"
 
           # 6. 保存项目名称到实例变量
           @proj_name = upload_proj_name
@@ -532,9 +448,10 @@ module Pindo
               puts "[PINDO_DEBUG] 配置加载结果: valid=#{config_result[:valid]}" if ENV['PINDO_DEBUG']
 
               if config_result[:valid]
+                is_git_config = manage_type.to_s == "git"
                 puts "\n使用 JPSBuildConfig.json 配置:"
                 puts "  项目: #{config_result[:project_name]}"
-                puts "  工作流: #{config_result[:workflow_info][:tab_name]}"
+                puts "  #{is_git_config ? '工作流' : '工具'}: #{config_result[:workflow_info][:tab_name]}"
 
                 if ENV['PINDO_DEBUG']
                   puts "[PINDO_DEBUG] 配置详细信息:"
@@ -547,6 +464,27 @@ module Pindo
                   raise Informative, "JPS 未登录或登录已失效，请执行 pindo jps login 重新登录"
                 end
 
+                # 安装包配置只有 workflow_id（旧格式）时，换算成 package_id 并写回；
+                # 找不到对应工具则落到下方交互重选流程
+                unless is_git_config
+                  migrated = migrate_legacy_workflow_info!(
+                    config_path: config_path,
+                    project_id: config_result[:project_id],
+                    package_type: package_type,
+                    workflow_info: config_result[:workflow_info]
+                  )
+                  if migrated.nil?
+                    puts "旧工作流（ID: #{config_result[:workflow_info][:workflow_id]}）未找到对应工具，将重新选择"
+                    config_result[:valid] = false
+                    # 项目已知，只需重选工具：走下方 --proj 非交互项目解析分支
+                    proj_name = config_result[:project_name]
+                  else
+                    config_result[:workflow_info] = migrated
+                  end
+                end
+              end
+
+              if config_result[:valid]
                 puts "[PINDO_DEBUG] 正在查找项目: #{config_result[:project_name]}" if ENV['PINDO_DEBUG']
                 lookup_bundle_id = resolve_lookup_bundle_id(
                   bundle_name: bundle_name,
@@ -740,9 +678,11 @@ module Pindo
 
         def start_upload(app_info_obj:nil, ipa_file_upload:nil, description:nil, workflow_info:nil)
 
-                # 验证 workflow_info 必传
-                if workflow_info.nil? || workflow_info[:workflow_id].nil?
-                    raise Informative, "workflow_info 和 workflow_id 是必传参数，请确保调用 prepare_upload 时传入了 package_type"
+                # 验证工具信息必传：package_id 优先，旧配置换算不到时才用 workflow_id 兼容
+                package_id = workflow_info && workflow_info[:package_id].to_s.strip
+                workflow_id = workflow_info && workflow_info[:workflow_id]
+                if workflow_info.nil? || (package_id.to_s.empty? && (workflow_id.nil? || workflow_id.to_s.empty?))
+                    raise Informative, "缺少工具信息（package_id），请确保调用 prepare_upload 时传入了 package_type"
                 end
 
                 if !ipa_file_upload.nil? &&
@@ -901,13 +841,13 @@ module Pindo
 
                     puts attachFileUrls
 
-                    # 准备上传参数（workflowId 必传）
-                    upload_params = {
+                    upload_params = build_package_upload_params(
                         description: description,
-                        packageUrl: upload_res,
-                        attachFileUrls: attachFileUrls,
-                        workflowId: workflow_info[:workflow_id]  # workflowId 必传
-                    }
+                        package_url: upload_res,
+                        attach_file_urls: attachFileUrls,
+                        package_id: package_id,
+                        workflow_id: workflow_id
+                    )
 
                     # 提交包信息到服务器
                     Funlog.instance.fancyinfo_start("正在提交包信息到服务器...")
@@ -926,7 +866,9 @@ module Pindo
                         if result_data && result_data["data"] && result_data["data"]["id"]
                             Funlog.instance.fancyinfo_success("提交包信息完成!")
                         else
-                            error_msg = result_data&.dig('msg') || '未知错误'
+                            error_msg = result_data&.dig('msg') || result_data&.dig('meta', 'message') || '未知错误'
+                            hint = package_upload_error_hint(result_data)
+                            error_msg = "#{error_msg}（#{hint}）" if hint
                             Funlog.instance.fancyinfo_error("提交包信息失败: #{error_msg}")
                             raise Informative, "上传失败：未获取到有效的返回数据"
                         end
@@ -945,6 +887,37 @@ module Pindo
 
         end
 
+        # 项目包上传错误码 → 处理提示
+        PACKAGE_UPLOAD_ERROR_HINTS = {
+          97931 => "未传 packageId，请重新执行 pindo jps config 绑定工具",
+          97992 => "packageId 与 workflowId 冲突，只应传 packageId",
+          97953 => "该工具不是安装包类型，不能走项目包上传"
+        }.freeze
+
+        # 组装项目包上传参数：packageId 与 workflowId 只传一个（同时传且不匹配会报 97992）
+        def build_package_upload_params(description:, package_url:, attach_file_urls:, package_id:, workflow_id:)
+          params = {
+            description: description,
+            packageUrl: package_url,
+            attachFileUrls: attach_file_urls
+          }
+          if !package_id.to_s.strip.empty?
+            params.merge(packageId: package_id.to_s.strip)
+          else
+            # 换算不到工具的旧配置：按 workflowId 兼容上传（JPS 长期兼容）
+            Funlog.instance.fancyinfo_warning("未绑定工具，按旧工作流ID兼容上传: #{workflow_id}")
+            params.merge(workflowId: workflow_id)
+          end
+        end
+
+        # 从上传返回体中取错误码提示（码可能在 code 或 meta.code）
+        def package_upload_error_hint(result_data)
+          return nil unless result_data.is_a?(Hash)
+          code = result_data['code'] || result_data.dig('meta', 'code')
+          return nil if code.nil?
+          PACKAGE_UPLOAD_ERROR_HINTS[code.to_i]
+        end
+
         def package_windows_exe_for_upload(exe_file_upload)
             windows_exe_path = File.expand_path(exe_file_upload)
             windows_build_dir = File.dirname(windows_exe_path)
@@ -1435,6 +1408,67 @@ module Pindo
           result&.dig("data")
         end
 
+        # 取项目下可上传的安装包工具（project/detail 的 packageTools）
+        # 按 package_type 筛选，去掉已下架（lifecycle=deprecated）和缺 packageId 的，保持接口返回的排序
+        #
+        # @param project_id [String] 项目ID
+        # @param package_type [String] 包类型（ipa/apk/zip/mac/exe）
+        # @return [Array<Hash>] packageTools 原始项
+        def get_project_package_tools(project_id:, package_type:)
+          detail = get_project_detail(project_id: project_id)
+          tools = detail.is_a?(Hash) ? detail["packageTools"] : nil
+          return [] unless tools.is_a?(Array)
+
+          tools.select do |t|
+            t.is_a?(Hash) &&
+              t["packageType"].to_s.downcase == package_type.to_s.downcase &&
+              t["lifecycle"].to_s != "deprecated" &&
+              !t["packageId"].to_s.strip.empty?
+          end
+        end
+
+        # 工具显示名：name（subtitle），与 GoodUnityBuild 写入的 tab_name 保持一致
+        def package_tool_display_name(tool)
+          name = tool["name"].to_s
+          subtitle = tool["subtitle"].to_s
+          subtitle.strip.empty? ? name : "#{name}（#{subtitle}）"
+        end
+
+        # 工具 → workflow_info（沿用 symbol key 结构，调用方无需改动）
+        def package_tool_to_workflow_info(tool, package_type)
+          {
+            package_id: tool["packageId"].to_s,
+            workflow_id: tool["workflowId"],          # 老工具才有；新工具为 nil，仅用于兼容
+            tab_name: package_tool_display_name(tool),
+            package_name: tool["name"],
+            package_type: package_type,
+            manage_type: "package",
+            subtitle: tool["subtitle"],
+            bundle_id: tool["bundleId"]
+          }
+        end
+
+        # 旧配置（只有 workflow_id、没有 package_id）换算成工具并写回配置文件
+        # 已有 package_id → 原样返回、不发请求；只有 workflow_id → 在 packageTools 里按 workflowId 查找
+        #
+        # @return [Hash, nil] 换算后的 workflow_info；找不到对应工具返回 nil
+        def migrate_legacy_workflow_info!(config_path:, project_id:, package_type:, workflow_info:)
+          return workflow_info unless workflow_info[:package_id].to_s.strip.empty?
+          return nil if workflow_info[:workflow_id].nil? || workflow_info[:workflow_id].to_s.empty?
+
+          tool = get_project_package_tools(project_id: project_id, package_type: package_type)
+                   .find { |t| t["workflowId"].to_s == workflow_info[:workflow_id].to_s }
+          return nil if tool.nil?
+
+          new_info = package_tool_to_workflow_info(tool, package_type)
+          config = JSON.parse(File.read(config_path))
+          key = jps_workflow_key(package_type: package_type)
+          config[key] = build_workflow_data(workflow_info: new_info, package_type: package_type)
+          atomic_write(config_path, JSON.pretty_generate(config))
+          puts "已将旧工作流（ID: #{workflow_info[:workflow_id]}）换算为工具: #{new_info[:tab_name]}"
+          new_info
+        end
+
         PROJECT_PAGE_SIZE = 100
         # 安全上限：最多翻 200 页（约 2 万项目），防止服务端异常（如忽略 pageNo 恒返满页）导致死循环
         MAX_PROJECT_PAGES = 200
@@ -2210,7 +2244,7 @@ module Pindo
           end
 
           atomic_write(config_file, JSON.pretty_generate(config) + "\n")
-          puts "已写入 JPSBuildConfig.json（#{entries.size} 个工作流）"
+          puts "已写入 JPSBuildConfig.json（#{entries.size} 项绑定）"
           config
         end
 
@@ -2252,10 +2286,34 @@ module Pindo
           end
         end
 
-        # 构建单个工作流的写入结构
+        # 包类型 → 显示名
+        def package_type_desc(package_type)
+          case package_type
+          when 'ipa' then 'iOS IPA'
+          when 'apk' then 'Android APK'
+          when 'zip' then 'WebGL'
+          when 'mac' then 'macOS App'
+          when 'exe' then 'Windows EXE'
+          else package_type.to_s
+          end
+        end
+
+        # HighLine 菜单选择，返回 items 中与所选 choice 同下标的元素
+        def choose_from_menu(prompt:, choices:, items:)
+          cli = HighLine.new
+          selected = cli.choose do |menu|
+            menu.prompt = prompt
+            menu.choices(*choices)
+          end
+          items[choices.index(selected)]
+        end
+
+        # 构建单个工作流/工具的写入结构（与 GoodUnityBuild 共用的 JPSBuildConfig.json 格式）
+        # 安装包工具：package_id 为上传依据，workflow_id 仅兼容（新工具为 nil）；Git 工作流：package_id 为空串
         def build_workflow_data(workflow_info:, package_type:)
           {
             "workflow_id" => workflow_info[:workflow_id],
+            "package_id" => workflow_info[:package_id].to_s,
             "tab_name" => workflow_info[:tab_name],
             "package_type" => package_type,
             "package_name" => workflow_info[:package_name],
@@ -2268,20 +2326,24 @@ module Pindo
         # @param workflow [Hash] 工作流配置对象
         # @return [Boolean] 是否有效
         def workflow_valid?(workflow)
-          return false if workflow.nil?
+          return false unless workflow.is_a?(Hash)
 
-          # 检查 workflow_id
-          return false if workflow['workflow_id'].nil? || workflow['workflow_id'].to_s.empty?
-
-          # git 类型的 workflow 不需要 package_name（管理 git commit，不是包文件）
-          # 其他类型的 workflow 需要 package_name
           is_git_workflow = workflow['manage_type'] == 'git'
-          unless is_git_workflow
-            return false if workflow['package_name'].nil? || workflow['package_name'].empty?
+          has_workflow_id = !workflow['workflow_id'].nil? && !workflow['workflow_id'].to_s.empty?
+          has_package_id = !workflow['package_id'].to_s.strip.empty?
+
+          if is_git_workflow
+            # Git 工作流必须有 workflow_id，不需要 package_name
+            return false unless has_workflow_id
+          else
+            # 安装包工具：package_id / workflow_id 有一个即可（只有 workflow_id 的旧配置在 prepare_upload 中换算）
+            return false unless has_package_id || has_workflow_id
+            return false if workflow['package_name'].nil? || workflow['package_name'].to_s.empty?
           end
 
           if ENV['PINDO_DEBUG']
             puts "[PINDO_DEBUG] workflow_valid? 检查通过:"
+            puts "  package_id: #{workflow['package_id']}"
             puts "  workflow_id: #{workflow['workflow_id']}"
             puts "  manage_type: #{workflow['manage_type']}"
             puts "  is_git_workflow: #{is_git_workflow}"
@@ -2395,14 +2457,18 @@ module Pindo
           end
 
           # 8. Project ID 不变，检查工作流是否需要更新
+          # 安装包按 package_id 比较（新工具 workflow_id 都是 nil）；Git 按 workflow_id 比较
           existing_workflow = existing_config[workflow_key]
-          existing_workflow_id = existing_workflow&.dig('workflow_id')
-
-          if existing_workflow_id.nil? ||
-             existing_workflow_id.to_s.empty? ||
-             existing_workflow_id != workflow_info[:workflow_id]
+          changed = if manage_type.to_s == 'git'
+            existing_workflow_id = existing_workflow.is_a?(Hash) ? existing_workflow['workflow_id'] : nil
+            existing_workflow_id.to_s.empty? || existing_workflow_id.to_s != workflow_info[:workflow_id].to_s
+          else
+            existing_package_id = existing_workflow.is_a?(Hash) ? existing_workflow['package_id'] : nil
+            existing_package_id.to_s.empty? || existing_package_id.to_s != workflow_info[:package_id].to_s
+          end
 
-            # Workflow ID 变更 → 更新对应的 workflow 和项目信息
+          if changed
+            # 工作流/工具变更 → 更新对应的 workflow 和项目信息
             puts "#{workflow_key} 变更，更新工作流配置"
             existing_config[workflow_key] = new_workflow_data
             existing_config["bundle_group_name"] = new_bundle_group_name
@@ -2412,7 +2478,7 @@ module Pindo
             return
           end
 
-          # 9. Project ID 和 Workflow ID 都不变 → 不修改
+          # 9. Project ID 和工作流/工具都不变 → 不修改
           puts "配置未变更，跳过保存" if ENV['PINDO_DEBUG']
         end
     end

data/lib/pindo/module/task/model/nuget/nuget_upload_task.rb

@@ -7,6 +7,9 @@ module Pindo
     class NugetUploadTask < NugetTask
 
       DEFAULT_NUGET_BUCKET_NAME = 'nuget-resource'.freeze
+      # NuGet 登记项目：JPS「Unity 组件」项目
+      # （原「Nuget 组件库」5e6b36f61b614ed88086373ef874616c 已停止接收 NuGet 登记，返回 90006）
+      NUGET_PROJECT_ID = '1b9f111539ba4715abb2011fbfe46fd8'.freeze
 
       attr_reader :nupkg_file
 
@@ -132,8 +135,8 @@ module Pindo
         puts "✅ 登录成功"
         puts
 
-        # 2. 使用固定的 Nuget 组件库项目 ID
-        nuget_project_id = '5e6b36f61b614ed88086373ef874616c'
+        # 2. 使用固定的 NuGet 登记项目（Unity 组件）
+        nuget_project_id = NUGET_PROJECT_ID
         puts
 
         # 3. 上传文件到存储

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

@@ -177,13 +177,13 @@ module Pindo
 
           workflow_name: OptionItem.new(
             key: :workflow_name,
-            name: '工作流名称',
-            description: '按名称指定工作流，用于某类型匹配到多个工作流时消歧（非交互场景使用）',
+            name: '工作流/工具名称',
+            description: '按名称精确选择 Git 工作流或安装包工具（工具可匹配 name、subtitle 或 name（subtitle）），用于同类型多个时消歧（非交互场景使用）',
             type: String,
             env_name: 'PINDO_JPS_WORKFLOW_NAME',
             optional: true,
             cacheable: false,
-            example: 'pindo jps config --proj=MyApp --type=ipa --workflow_name="iOS IPA Upload"'
+            example: 'pindo jps config --proj=MyApp --type=ipa --workflow_name="iOS提交包"'
           )
         }
       end

data/lib/pindo/version.rb

@@ -6,7 +6,7 @@ require 'time'
 
 module Pindo
 
-  VERSION = "5.21.5"
+  VERSION = "5.22.0"
 
   class VersionCheck
     RUBYGEMS_API = 'https://rubygems.org/api/v1/gems/pindo.json'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pindo
 version: !ruby/object:Gem::Version
-  version: 5.21.5
+  version: 5.22.0
 platform: ruby
 authors:
 - wade
@@ -536,7 +536,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.0.0
 requirements: []
-rubygems_version: 4.0.11
+rubygems_version: 4.0.10
 specification_version: 4
 summary: easy work
 test_files: []