pindo 5.20.3 → 5.20.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b1febabe3ba7ca2b2d8bd2e3f005e6aec1226b7d7881b3aebec6b6d5af1c5f0
-  data.tar.gz: bd12f36dfa900606bb82154406f6d85dbf37bcb1e16abfcd0aaa48341734d20a
+  metadata.gz: 51a9e1f1176906c3f5cc98d5c8654bd194c2199eca4d056c5d24b84d321a0e7f
+  data.tar.gz: 983e11201e2b488800fb65a745300fc71184e068e01f94255ae29d2f469c3d02
 SHA512:
-  metadata.gz: f780b333edd0ae1272d15af1c641e41c481c8ad06ded6bbd7d253f662f54de34b707ccd2e0a91097728da293ead5c053e6d1a8ea652722897a7e572e0c2ec26e
-  data.tar.gz: 88e50426cfeb85c798610f64935a1e8053d6200da20920a450c2940c79b451e78be918d55d94ea2f186d2a2feb4773b15d6e7221b294d497f4e8470a626c145d
+  metadata.gz: 140c5a77bf8ad4e46547a60caef4587e04811450624a0c19213b978fae267078b8d6370486209531d4116ab202670ce12a707edc93c7299df1e4e244f389668d
+  data.tar.gz: f646d8f611a70c2ad39bdaa31ef69f55f4a0946ed3e1c90a27d806072ca2484c1bcf7ec8073d9e381031d2ab645aceaf5387cb13b8e90ed6e20070acee5f5a6a

data/lib/pindo/base/git_handler.rb

@@ -149,6 +149,21 @@ module Pindo
           []
       end
 
+      # 获取仓库当前所在分支名
+      # @param local_repo_dir [String] 仓库目录
+      # @return [String, nil] 分支名；detached HEAD、非仓库或读取失败时返回 nil
+      def current_branch_name(local_repo_dir: nil)
+          return nil if local_repo_dir.nil?
+
+          branch = git!(%W(-C #{local_repo_dir} rev-parse --abbrev-ref HEAD)).strip
+          # detached HEAD 时 git 返回字面量 "HEAD"，不是分支名
+          return nil if branch.empty? || branch == 'HEAD'
+
+          branch
+      rescue StandardError
+          nil
+      end
+
       # 解析发布分支（当用户未显式指定时给出合理默认）：
       #   1) preferred（用户 --release_branch 或默认值）在远程存在 → 用它（master 仓库、显式指定均走此）
       #   2) 否则远程有 master → master
@@ -697,12 +712,10 @@ module Pindo
             Funlog.instance.fancyinfo_success("push文件完成!")
         end
 
+        # 丢弃工作区全部改动
+        # 不在此处二次确认：交互模式下 get_uncommitted_files_process_type 选中 reset 时
+        # 已经对着文件清单确认过；非交互模式（--git-commit=reset / CI）本就不该阻塞等待输入。
         def handle_delete_all(project_dir, branch)
-            answer = agree("有未提交的文件，确认删除？(Y/n）:")
-            unless answer
-                raise Informative, "请手动处理未提交的文件！！！"
-            end
-
             Funlog.instance.fancyinfo_start("开始删除未提交的文件...")
             git!(%W(-C #{project_dir} reset --hard))
             git!(%W(-C #{project_dir} clean -df))
@@ -759,13 +772,17 @@ module Pindo
           end
       end
 
-      # 获取最新的符合规范的 commit
+      # 获取本次构建对应的 commit
       # @param project_dir [String] 项目目录路径
-      # @param tag_prefix [String] tag前缀，用于检查 HEAD 是否有版本 tag，默认 'v'
+      # @param tag_prefix [String] tag前缀，用于识别 HEAD 上的版本 tag，默认 'v'
       # @return [Hash] 包含 :commit_id, :commit_time, :commit_desc
-      # 优先级：
-      #   1. 如果 HEAD 存在版本 tag，直接返回 HEAD（认为有 tag 的 commit 是有效的发布节点）
-      #   2. 否则，返回最新的符合 Conventional Commits 规范的提交
+      #
+      # commit_id 与 commit_time 恒为 HEAD：调用方（包绑定、媒体上传、工作流消息）
+      # 要的是「本次构建所在的节点」，提交信息是否符合 Conventional Commits、
+      # 是不是 merge commit，都不改变这一点——沿历史回溯只会关联到与本次构建无关的祖先提交。
+      #
+      # 只有 commit_desc 会被替换：HEAD 是 merge commit 时其描述通常是无信息量的
+      # "Merge branch ..."，此时从最近 15 条非 merge 提交中借用一条规范提交的描述。
       def get_latest_conventional_commit(project_dir:nil, tag_prefix: 'v')
           result = {
             commit_id: nil,
@@ -780,75 +797,65 @@ module Pindo
           return result unless git_root
 
           begin
-            # 优先级 1: 检查 HEAD 是否有版本 tag
-            if head_has_version_tag?(project_dir: git_root, tag_prefix: tag_prefix)
-              # HEAD 有版本 tag，直接返回 HEAD 的 commit 信息
-              head_info = git!(%W(-C #{git_root} log -1 --format=%H|%ci|%s HEAD)).strip
-              if !head_info.empty?
-                parts = head_info.split('|', 3)
-                result[:commit_id] = parts[0]
-                result[:commit_time] = parts[1]
-                result[:commit_desc] = parts[2]&.force_encoding('UTF-8')&.scrub('')
-                puts "  HEAD 存在版本 tag，使用 HEAD commit: #{result[:commit_desc]}"
-                return result
-              end
-            end
-
-            # 优先级 2: 获取最近 15 条 commit 历史（排除 merge commits）
-            output = git!(%W(-C #{git_root} log -15 --no-merges --format=%H|%ci|%s)).strip
-
-            if output.empty?
+            # 1. 取 HEAD 的 commit 信息（commit_id / commit_time 以此为准）
+            head_info = git!(%W(-C #{git_root} log -1 --format=%H|%ci|%s HEAD)).strip
+            if head_info.empty?
               Funlog.instance.warning("未找到 git commit 历史")
               return result
             end
 
-            # 解析 commit 列表
-            commits = output.split("\n").map do |line|
-              parts = line.split('|', 3)
-              {
-                commit_id: parts[0],
-                commit_time: parts[1],
-                commit_desc: parts[2]&.force_encoding('UTF-8')&.scrub('')
-              }
-            end
-
-            # 定义符合规范的提交类型（Conventional Commits 规范）
-            valid_types = ['feat', 'fix', 'docs', 'style', 'refactor', 'perf', 'test', 'build', 'ci', 'chore', 'revert']
+            parts = head_info.split('|', 3)
+            result[:commit_id] = parts[0]
+            result[:commit_time] = parts[1]
+            result[:commit_desc] = parts[2]&.force_encoding('UTF-8')&.scrub('')
 
-            # 筛选符合规范的提交（支持 type: 和 type(scope): 两种格式）
-            conventional_commits = commits.select do |commit|
-              desc = commit[:commit_desc].to_s.strip.downcase
-              # 匹配 "type:" 或 "type(" 格式（允许 scope）
-              valid_types.any? do |type|
-                desc.start_with?("#{type}:") || desc.start_with?("#{type}(")
-              end
+            if head_has_version_tag?(project_dir: git_root, tag_prefix: tag_prefix)
+              puts "  HEAD 存在版本 tag，使用 HEAD commit: #{result[:commit_desc]}"
+              return result
             end
 
-            if conventional_commits.empty?
-              Funlog.instance.warning("在最近15个提交中未找到符合规范的提交（feat:, fix: 等开头）")
-              Funlog.instance.warning("使用最新的提交（HEAD）")
-
-              # 降级：使用 HEAD
-              result[:commit_id] = commits.first[:commit_id]
-              result[:commit_time] = commits.first[:commit_time]
-              result[:commit_desc] = commits.first[:commit_desc]
-            else
-              # 使用最新的符合规范的提交（第一个）
-              latest = conventional_commits.first
-              result[:commit_id] = latest[:commit_id]
-              result[:commit_time] = latest[:commit_time]
-              result[:commit_desc] = latest[:commit_desc]
-
-              puts "  找到符合规范的提交: #{result[:commit_desc]}"
+            # 2. HEAD 不是 merge commit：描述本身有效，直接返回
+            head_parents = git!(%W(-C #{git_root} rev-list --parents -1 HEAD)).strip.split(/\s+/)
+            unless head_parents.size > 2
+              puts "  使用 HEAD commit: #{result[:commit_desc]}"
+              return result
             end
+
+            # 3. HEAD 是 merge commit：commit 仍用 HEAD，只借用祖先的规范提交描述
+            result[:commit_desc] = borrow_conventional_desc(git_root) || result[:commit_desc]
+            puts "  HEAD 为 merge commit，使用 HEAD commit + 祖先描述: #{result[:commit_desc]}"
           rescue StandardError => e
-            Funlog.instance.warning("获取 conventional commit 失败: #{e.message}")
+            Funlog.instance.warning("获取 commit 信息失败: #{e.message}")
             return result
           end
 
           result
       end
 
+      # 从最近 15 条非 merge 提交中找一条符合 Conventional Commits 规范的描述
+      # 仅供 get_latest_conventional_commit 内部使用（本文件的类方法均为 public，
+      # 加 private 会影响同块内其它对外方法，故以注释标注）
+      # @param git_root [String] git 根目录
+      # @return [String, nil] 提交描述；找不到时返回 nil
+      def borrow_conventional_desc(git_root)
+          output = git!(%W(-C #{git_root} log -15 --no-merges --format=%s)).strip
+          return nil if output.empty?
+
+          descs = output.split("\n").map { |line| line&.force_encoding('UTF-8')&.scrub('') }
+
+          # 符合规范的提交类型（Conventional Commits 规范），支持 type: 与 type(scope): 两种格式
+          valid_types = ['feat', 'fix', 'docs', 'style', 'refactor', 'perf', 'test', 'build', 'ci', 'chore', 'revert']
+          conventional = descs.find do |desc|
+            normalized = desc.to_s.strip.downcase
+            valid_types.any? { |type| normalized.start_with?("#{type}:") || normalized.start_with?("#{type}(") }
+          end
+
+          return conventional if conventional
+
+          Funlog.instance.warning("在最近15个提交中未找到符合规范的提交（feat:, fix: 等开头），保留 merge commit 描述")
+          nil
+      end
+
       # 创建新的版本标签
       # @param project_dir [String] 项目目录路径
       # @param tag_prefix [String] 标签前缀
@@ -990,16 +997,33 @@ module Pindo
         display_file_status(current_branch, uncommitted_files)
 
         # 5. 交互式选择
+        # 危险选项在这里就地二次确认：此时未提交文件列表还在屏幕上，用户能看着清单做决定。
+        # 若把确认延后到任务执行阶段，中间会隔着任务计划输出，用户看不到自己要丢弃的是哪些文件。
         cli = HighLine.new
-        cli.choose do |menu|
-          menu.header = "仓库有未提交的修改，请选择处理方式"
-          menu.prompt = "请输入选项(1/2/3/4/5/6):"
-          menu.choice("(commit) 全部提交") { Pindo::UncommittedFilesProcessType::COMMIT }
-          menu.choice("(skip-with-tag) 不提交，但合并分支并打tag") { Pindo::UncommittedFilesProcessType::SKIP_WITH_TAG }
-          menu.choice("(skip-without-tag) 不提交，不合并分支，不打tag") { Pindo::UncommittedFilesProcessType::SKIP_WITHOUT_TAG }
-          menu.choice("(reset) 全部丢弃更改，回滚代码") { Pindo::UncommittedFilesProcessType::RESET }
-          menu.choice("(stash) 保存到stash区域（该部分代码本次编译不生效）") { Pindo::UncommittedFilesProcessType::STASH }
-          menu.choice("(exit) 先退出，手动来处理退出") { Pindo::UncommittedFilesProcessType::EXIT }
+        loop do
+          choice = cli.choose do |menu|
+            menu.header = "仓库有未提交的修改，请选择处理方式"
+            menu.prompt = "请输入选项(1/2/3/4/5/6):"
+            menu.choice("(commit) 全部提交") { Pindo::UncommittedFilesProcessType::COMMIT }
+            menu.choice("(skip-with-tag) 不提交，但合并分支并打tag") { Pindo::UncommittedFilesProcessType::SKIP_WITH_TAG }
+            menu.choice("(skip-without-tag) 不提交，不合并分支，不打tag") { Pindo::UncommittedFilesProcessType::SKIP_WITHOUT_TAG }
+            menu.choice("(reset) 全部丢弃更改，回滚代码") { Pindo::UncommittedFilesProcessType::RESET }
+            menu.choice("(stash) 保存到stash区域（该部分代码本次编译不生效）") { Pindo::UncommittedFilesProcessType::STASH }
+            menu.choice("(exit) 先退出，手动来处理退出") { Pindo::UncommittedFilesProcessType::EXIT }
+          end
+
+          # reset 会 reset --hard + clean -df，改动无法恢复，必须当场确认
+          if choice == Pindo::UncommittedFilesProcessType::RESET
+            puts
+            puts "⚠️  以上 #{Array(uncommitted_files).size} 个文件的修改将被永久丢弃，无法恢复".red
+            unless cli.agree("确认删除？(y/n) ")
+              puts "已取消，请重新选择处理方式".yellow
+              puts
+              next
+            end
+          end
+
+          return choice
         end
       end
 

data/lib/pindo/command/android/autobuild.rb

@@ -417,9 +417,13 @@ module Pindo
               tasks << message_task
             end
 
-            # 6. 创建媒体附件上传任务（如果需要，只依赖 Git 提交任务）
-            if @args_media_flag
-              # 获取 Git 管理类型的工作流（不同于 APK 上传的工作流）
+            # 6. 获取 Git 管理类型的工作流（media、bind、send 共用，不同于 APK 上传的包工作流）
+            # commit 记录挂在 Git 工作流下，媒体附件、包绑定、工作流消息都按它定位
+            git_app_info_obj = nil
+            git_workflow_info = nil
+            if @args_media_flag || @args_bind_flag || @args_send_flag
+              # 取不到就让异常冒泡：media/bind/send 都依赖它，静默跳过会让命令
+              # 明明没做用户要求的事却以 0 退出
               git_app_info_obj, git_workflow_info = PgyerHelper.share_instace.prepare_upload(
                 working_directory: config[:project_path],
                 conf: @args_conf,
@@ -427,48 +431,53 @@ module Pindo
                 manage_type: "git"
               )
 
+              unless git_app_info_obj && git_workflow_info
+                raise Informative, "未获取到 Git 类型的工作流；请在 JPS 后台配置 manage_type=git 的工作流"
+              end
+            end
+
+            # 7. 创建媒体附件上传任务（如果需要，依赖 Git 提交/打 Tag 任务）
+            if @args_media_flag
               media_upload_task = Pindo::TaskSystem::JPSUploadMediaTask.new(
                 [],  # 空数组，自动从 JPSMedia/ 目录查找
                 config[:project_path],  # upload_path
                 app_info_obj: git_app_info_obj,
                 workflow_info: git_workflow_info,
-                project_name: nil
+                project_name: nil,
+                required: @options[:media] || false  # 仅用户显式 --media 时，找不到文件才算失败
               )
               # 依赖 Git 提交任务
               media_upload_task.dependencies << git_commit_task.id
+              # 同样依赖 GitTagTask：并发模式下媒体上传可能与 build/tag 并行，
+              # 不依赖它就会关联到构建前的 commit，与包绑定的 commit 不一致
+              media_upload_task.dependencies << git_tag_task.id if git_tag_task
               tasks << media_upload_task
             end
 
-            # 7. 创建 Git Commit 绑定任务（如果需要，依赖上传任务）
+            # 8. 创建 Git Commit 绑定任务（如果需要，依赖上传任务）
             bind_package_task = nil  # 声明变量以便后续工作流消息任务使用
             if @args_bind_flag
               bind_package_task = Pindo::TaskSystem::JPSBindPackageTask.new(
                 nil,  # app_version_list 为 nil，从依赖任务获取
                 project_dir: config[:project_path],
-                app_info_obj: config[:app_info_obj],
-                workflow_info: config[:workflow_info],
+                app_info_obj: git_app_info_obj,      # 使用 Git app_info_obj
+                workflow_info: git_workflow_info,    # 使用 Git workflow_info
                 project_name: nil
               )
-              # 依赖上传任务和 Git 提交任务
+              # 依赖上传任务和 Git 任务
+              # GitTagTask 会提交构建注入文件并移动 HEAD，必须依赖它才能拿到 tag 所在的 commit
               bind_package_task.dependencies << upload_task.id
               bind_package_task.dependencies << git_commit_task.id
+              bind_package_task.dependencies << git_tag_task.id if git_tag_task
               tasks << bind_package_task
             end
 
-            # 8. 创建工作流消息任务（如果需要，发送到测试群）
+            # 9. 创建工作流消息任务（如果需要，发送到测试群）
             if @args_send_flag
-              # 获取 Git 工作流信息
-              git_app_info_obj, git_workflow_info = PgyerHelper.share_instace.prepare_upload(
-                working_directory: config[:project_path],
-                conf: @args_conf,
-                package_type: nil,
-                manage_type: "git"
-              )
-
               workflow_message_task = Pindo::TaskSystem::JPSWorkFlowMessageTask.new(
                 project_id: git_app_info_obj["id"],
-                workflow_id: git_workflow_info["id"],
-                branch: 'master',
+                workflow_id: git_workflow_info[:workflow_id],  # workflow_info 是 symbol key 结构，没有 "id" 键
+                # branch 不传：由任务从 Git 依赖任务取 resolve 之后的真实发布分支
                 single: true,
                 app_info_obj: git_app_info_obj,
                 workflow_info: git_workflow_info

data/lib/pindo/command/ios/autobuild.rb

@@ -132,7 +132,7 @@ module Pindo
                     @args_media_flag = @options[:send] || @options[:bind] || @options[:media] || false
 
                     # send 都依赖 bind：如果指定了任一参数，自动启用 bind
-                    @args_bind_flag = @options[:send] ||@options[:bind] || false
+                    @args_bind_flag = @options[:send] || @options[:bind] || false
 
                     @args_send_flag = @options[:send]
 
@@ -391,66 +391,67 @@ module Pindo
                             tasks << message_task
                         end
 
-                        # 6. 创建媒体附件上传任务（如果需要，只依赖 Git 提交任务）
-                        if @args_media_flag
-                            begin
-                                # 获取 Git 管理类型的工作流（不同于 IPA 上传的工作流）
-                                git_app_info_obj, git_workflow_info = PgyerHelper.share_instace.prepare_upload(
-                                    working_directory: config[:project_path],
-                                    conf: @args_conf,
-                                    package_type: nil,  # package_type 在 manage_type=git 时会被忽略
-                                    manage_type: "git"
-                                )
+                        # 6. 获取 Git 管理类型的工作流（media、bind、send 共用，不同于 IPA 上传的包工作流）
+                        # commit 记录挂在 Git 工作流下，媒体附件、包绑定、工作流消息都按它定位
+                        git_app_info_obj = nil
+                        git_workflow_info = nil
+                        if @args_media_flag || @args_bind_flag || @args_send_flag
+                            # 取不到就让异常冒泡：media/bind/send 都依赖它，静默跳过会让命令
+                            # 明明没做用户要求的事却以 0 退出
+                            git_app_info_obj, git_workflow_info = PgyerHelper.share_instace.prepare_upload(
+                                working_directory: config[:project_path],
+                                conf: @args_conf,
+                                package_type: nil,  # package_type 在 manage_type=git 时会被忽略
+                                manage_type: "git"
+                            )
 
-                                media_upload_task = Pindo::TaskSystem::JPSUploadMediaTask.new(
-                                    [],  # 空数组，自动从 JPSMedia/ 目录查找
-                                    config[:project_path],  # upload_path
-                                    app_info_obj: git_app_info_obj,
-                                    workflow_info: git_workflow_info,
-                                    project_name: nil
-                                )
-                                # 依赖 Git 提交任务
-                                media_upload_task.dependencies << git_commit_task.id
-                                tasks << media_upload_task
-                            rescue => e
-                                puts ""
-                                puts "  ⚠️  跳过媒体上传任务: #{e.message}"
-                                puts "  💡 提示: 请在 JPS 后台配置 Git 类型的工作流（manage_type: git）"
-                                puts ""
-                                # 不抛出异常，继续执行后续任务
+                            unless git_app_info_obj && git_workflow_info
+                                raise Informative, "未获取到 Git 类型的工作流；请在 JPS 后台配置 manage_type=git 的工作流"
                             end
                         end
 
-                        # 7. 创建 Git Commit 绑定任务（如果需要，依赖上传任务）
+                        # 7. 创建媒体附件上传任务（如果需要，依赖 Git 提交/打 Tag 任务）
+                        if @args_media_flag
+                            media_upload_task = Pindo::TaskSystem::JPSUploadMediaTask.new(
+                                [],  # 空数组，自动从 JPSMedia/ 目录查找
+                                config[:project_path],  # upload_path
+                                app_info_obj: git_app_info_obj,
+                                workflow_info: git_workflow_info,
+                                project_name: nil,
+                                required: @options[:media] || false  # 仅用户显式 --media 时，找不到文件才算失败
+                            )
+                            # 依赖 Git 提交任务
+                            media_upload_task.dependencies << git_commit_task.id
+                            # 同样依赖 GitTagTask：并发模式下媒体上传可能与 build/tag 并行，
+                            # 不依赖它就会关联到构建前的 commit，与包绑定的 commit 不一致
+                            media_upload_task.dependencies << git_tag_task.id if git_tag_task
+                            tasks << media_upload_task
+                        end
+
+                        # 8. 创建 Git Commit 绑定任务（如果需要，依赖上传任务）
                         bind_package_task = nil  # 声明变量以便后续工作流消息任务使用
                         if @args_bind_flag
                             bind_package_task = Pindo::TaskSystem::JPSBindPackageTask.new(
                                 nil,  # app_version_list 为 nil，从依赖任务获取
                                 project_dir: config[:project_path],
-                                app_info_obj: config[:app_info_obj],
-                                workflow_info: config[:workflow_info],
+                                app_info_obj: git_app_info_obj,      # 使用 Git app_info_obj
+                                workflow_info: git_workflow_info,    # 使用 Git workflow_info
                                 project_name: nil
                             )
-                            # 依赖上传任务和 Git 提交任务
+                            # 依赖上传任务和 Git 任务
+                            # GitTagTask 会提交构建注入文件并移动 HEAD，必须依赖它才能拿到 tag 所在的 commit
                             bind_package_task.dependencies << upload_task.id
                             bind_package_task.dependencies << git_commit_task.id
+                            bind_package_task.dependencies << git_tag_task.id if git_tag_task
                             tasks << bind_package_task
                         end
 
-                        # 8. 创建工作流消息任务（如果需要，发送到测试群）
+                        # 9. 创建工作流消息任务（如果需要，发送到测试群）
                         if @args_send_flag
-                            # 获取 Git 工作流信息
-                            git_app_info_obj, git_workflow_info = PgyerHelper.share_instace.prepare_upload(
-                                working_directory: config[:project_path],
-                                conf: @args_conf,
-                                package_type: nil,
-                                manage_type: "git"
-                            )
-
                             workflow_message_task = Pindo::TaskSystem::JPSWorkFlowMessageTask.new(
                                 project_id: git_app_info_obj["id"],
-                                workflow_id: git_workflow_info["id"],
-                                branch: 'master',
+                                workflow_id: git_workflow_info[:workflow_id],  # workflow_info 是 symbol key 结构，没有 "id" 键
+                                # branch 不传：由任务从 Git 依赖任务取 resolve 之后的真实发布分支
                                 single: true,
                                 app_info_obj: git_app_info_obj,
                                 workflow_info: git_workflow_info

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

@@ -125,6 +125,7 @@ module Pindo
                         git_commit_id = nil
                         git_commit_time = nil
                         git_commit_desc = nil
+                        git_branch = nil
 
                         # 1. 检测是否在 Git 仓库中
                         git_root = Pindo::GitHandler.git_root_directory(local_repo_dir: project_path)
@@ -136,6 +137,10 @@ module Pindo
                             git_commit_id = git_info[:commit_id]
                             git_commit_time = git_info[:commit_time]
                             git_commit_desc = git_info[:commit_desc]
+                            # commit 取的是当前 HEAD，分支就必须配当前分支：
+                            # 这里没有 autobuild 那样的合并到发布分支流程，用发布分支会发出
+                            # 「feature 分支的 commit + master 分支名」这种自相矛盾的组合
+                            git_branch = Pindo::GitHandler.current_branch_name(local_repo_dir: git_root)
 
                             if git_commit_id
                                 puts "     └─ Commit: #{git_commit_id[0..7]}"
@@ -145,7 +150,7 @@ module Pindo
                             # 3. 不在 Git 仓库中，获取工作流中最新的 commit id
                             puts "  📡 未检测到 Git 仓库，从工作流获取最新 commit..."
                             git_commit_id = pgyer_helper.get_workflow_latest_commit_id(
-                                workflow_id: git_workflow_info["id"]
+                                workflow_id: git_workflow_info[:workflow_id]  # workflow_info 是 symbol key 结构，没有 "id" 键
                             )
 
                             if git_commit_id
@@ -157,11 +162,11 @@ module Pindo
 
                         workflow_message_task = Pindo::TaskSystem::JPSWorkFlowMessageTask.new(
                             project_id: git_app_info_obj["id"],
-                            workflow_id: git_workflow_info["id"],
+                            workflow_id: git_workflow_info[:workflow_id],  # workflow_info 是 symbol key 结构，没有 "id" 键
                             git_commit_id: git_commit_id,
                             git_commit_time: git_commit_time,
                             git_commit_desc: git_commit_desc,
-                            branch: 'master',
+                            branch: git_branch,  # 不在 Git 仓库时为 nil，由任务兜底
                             single: true,
                             app_info_obj: git_app_info_obj,
                             workflow_info: git_workflow_info

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

@@ -154,7 +154,8 @@ module Pindo
                         project_name: nil,
                         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)
+                        git_commit_desc: selected_commit_info&.dig(:commit_desc),
+                        required: true  # 本命令就是为上传媒体而执行，没有文件可传即失败
                     )
                     # Media 上传任务依赖 Git 提交任务
                     media_upload_task.dependencies << git_commit_task.id

data/lib/pindo/command/unity/autobuild.rb

@@ -353,29 +353,39 @@ module Pindo
                     end
 
                     # 第五步：获取 Git 工作流信息（如果需要 media、bind 或 send）
+                    # commit 记录挂在 Git 工作流下，媒体附件、包绑定、工作流消息都按它定位
                     git_app_info_obj = nil
                     git_workflow_info = nil
                     if @args_media_flag || @args_bind_flag || @args_send_flag
-                        # 获取 Git 工作流信息（media、绑定、消息任务都需要）
+                        # 取不到就让异常冒泡：media/bind/send 都依赖它，静默跳过会让命令
+                        # 明明没做用户要求的事却以 0 退出
                         git_app_info_obj, git_workflow_info = PgyerHelper.share_instace.prepare_upload(
                             working_directory: Dir.pwd,
                             conf: @args_conf,
                             package_type: nil,  # package_type 在 manage_type=git 时会被忽略
                             manage_type: "git"
                         )
+
+                        unless git_app_info_obj && git_workflow_info
+                            raise Informative, "未获取到 Git 类型的工作流；请在 JPS 后台配置 manage_type=git 的工作流"
+                        end
                     end
 
-                    # 第六步：创建媒体附件上传任务（如果需要，只依赖 Git 提交任务）
+                    # 第六步：创建媒体附件上传任务（如果需要，依赖 Git 提交/打 Tag 任务）
                     if @args_media_flag
                         media_upload_task = Pindo::TaskSystem::JPSUploadMediaTask.new(
                             [],  # 空数组，自动从 JPSMedia/ 目录查找
                             Dir.pwd,  # upload_path
                             app_info_obj: git_app_info_obj,
                             workflow_info: git_workflow_info,
-                            project_name: all_platform_configs["project_name"]
+                            project_name: all_platform_configs["project_name"],
+                            required: @options[:media] || false  # 仅用户显式 --media 时，找不到文件才算失败
                         )
                         # 依赖 Git 提交任务
                         media_upload_task.dependencies << git_commit_task.id
+                        # 同样依赖 GitTagTask：并发模式下媒体上传可能与 build/tag 并行，
+                        # 不依赖它就会关联到构建前的 commit，与包绑定的 commit 不一致
+                        media_upload_task.dependencies << git_tag_task.id if git_tag_task
                         all_tasks << media_upload_task
                     end
 
@@ -389,21 +399,22 @@ module Pindo
                             workflow_info: git_workflow_info,      # 使用 Git workflow_info
                             project_name: all_platform_configs["project_name"]
                         )
-                        # 依赖所有平台的上传任务和 Git 提交任务
+                        # 依赖所有平台的上传任务和 Git 任务
+                        # GitTagTask 会提交构建注入文件并移动 HEAD，必须依赖它才能拿到 tag 所在的 commit
                         platform_upload_tasks.each do |upload_task|
                             bind_package_task.dependencies << upload_task.id
                         end
                         bind_package_task.dependencies << git_commit_task.id
+                        bind_package_task.dependencies << git_tag_task.id if git_tag_task
                         all_tasks << bind_package_task
                     end
 
                     # 第八步：创建工作流消息任务（如果需要，发送到测试群）
                     if @args_send_flag
-
                         workflow_message_task = Pindo::TaskSystem::JPSWorkFlowMessageTask.new(
                             project_id: git_app_info_obj["id"],
-                            workflow_id: git_workflow_info["id"],
-                            branch: 'master',
+                            workflow_id: git_workflow_info[:workflow_id],  # workflow_info 是 symbol key 结构，没有 "id" 键
+                            # branch 不传：由任务从 Git 依赖任务取 resolve 之后的真实发布分支
                             single: true,
                             app_info_obj: git_app_info_obj,
                             workflow_info: git_workflow_info