pindo 5.14.4 → 5.14.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb15b2496f39d434ab25b2609b651779fc38187e56990a40f66aeee02411da83
-  data.tar.gz: c0abb252891099cf6c45bda365737415d662b1d165bb027064779db171c0fbe0
+  metadata.gz: da83c30dd943e6edfa9320b5944d43b76fd467c2ebdf1aff2f010a07235628a9
+  data.tar.gz: a05b5d981a1431cfc9c0659d20966f4eaafee7433de93d27ebddb11310a57678
 SHA512:
-  metadata.gz: 3271d2f0516402ea4ee3f8716fe6d1fd4c1d0c1bc46e39ac65ed9c2fb00cb9f707dc44485acafb3e26a28b03b9069681f8a8d31c891534d144de614b53befb42
-  data.tar.gz: 170f1753ee18dd359dea8a8f918625f82a4cdbaf34ce0f4dcfc342492b5b3086296589ef650f942ca000772a033d796f7f7e949b20cc52c45deda55ae56cafe6
+  metadata.gz: bf83411f15e4a91b3c80d5add990d84e6a00513deee5943304a0a5cb72a29d9495d8cbbd14da5e8463bd4345d2e778997e7947cb7bc681d4046e362eb7fadb1d
+  data.tar.gz: efee3ed4cf27cc7206f57543865397dc126d3c4e902451a59b617e2547fa8c5fae96330dcd9c9b9f3b2ddc12545024537fe46620199a3261a32da8afb1dc7902

data/lib/pindo/base/git_handler.rb

@@ -859,98 +859,149 @@ module Pindo
 
 
 
-      # 合并到发布分支
+      # 合并分支
+      # 将源分支合并到目标分支，支持单向或双向同步
+      #
       # @param project_dir [String] 项目目录
-      # @param release_branch [String] 发布分支名称
-      # @param coding_branch [String] 当前开发分支名称
-      def merge_to_release_branch(project_dir:, release_branch:, coding_branch:)
+      # @param source_branch [String] 源分支名称（要合并的分支）
+      # @param target_branch [String] 目标分支名称（接收合并的分支）
+      # @param sync_branches [Boolean] 是否双向合并（同步两分支），默认 false
+      #   - true: 双向合并，source → target，然后 target → source（确保两分支完全同步）
+      #   - false: 单向合并，仅 source → target
+      # @return [void]
+      def merge_branches(project_dir:, source_branch:, target_branch:, sync_branches: false)
         current_project_dir = project_dir
-        Funlog.instance.fancyinfo_start("开始合并到#{release_branch}分支")
-        if !coding_branch.eql?(release_branch)
-          coding_branch_commit_id = git!(%W(-C #{current_project_dir} rev-parse #{coding_branch})).strip
-          release_branch_commit_id = nil
-
-          if remote_branch_exists?(local_repo_dir: current_project_dir, branch: release_branch)
-            Funlog.instance.fancyinfo_update("存在#{release_branch}远程分支")
-            if local_branch_exists?(local_repo_dir: current_project_dir, branch: release_branch)
-              Funlog.instance.fancyinfo_update("存在#{release_branch}本地分支")
-              git!(%W(-C #{current_project_dir} checkout #{release_branch}))
+        Funlog.instance.fancyinfo_start("开始合并到#{target_branch}分支")
+        if !source_branch.eql?(target_branch)
+          source_branch_commit_id = git!(%W(-C #{current_project_dir} rev-parse #{source_branch})).strip
+          target_branch_commit_id = nil
+
+          if remote_branch_exists?(local_repo_dir: current_project_dir, branch: target_branch)
+            Funlog.instance.fancyinfo_update("存在#{target_branch}远程分支")
+            if local_branch_exists?(local_repo_dir: current_project_dir, branch: target_branch)
+              Funlog.instance.fancyinfo_update("存在#{target_branch}本地分支")
+              git!(%W(-C #{current_project_dir} checkout #{target_branch}))
             else
-              Funlog.instance.fancyinfo_update("不存在#{release_branch}本地分支")
-              git!(%W(-C #{current_project_dir} checkout -b #{release_branch} origin/#{release_branch}))
+              Funlog.instance.fancyinfo_update("不存在#{target_branch}本地分支")
+              git!(%W(-C #{current_project_dir} checkout -b #{target_branch} origin/#{target_branch}))
             end
 
-            git!(%W(-C #{current_project_dir} branch --set-upstream-to=origin/#{release_branch} #{release_branch}))
-            git!(%W(-C #{current_project_dir} fetch origin #{release_branch}))
-            git!(%W(-C #{current_project_dir} merge origin/#{release_branch}))
+            git!(%W(-C #{current_project_dir} branch --set-upstream-to=origin/#{target_branch} #{target_branch}))
+            git!(%W(-C #{current_project_dir} fetch origin #{target_branch}))
+            git!(%W(-C #{current_project_dir} merge origin/#{target_branch}))
 
             # 执行合并操作
-            Executable.capture_command('git', %W(-C #{current_project_dir} merge #{coding_branch}), :capture => :out)
+            Executable.capture_command('git', %W(-C #{current_project_dir} merge #{source_branch}), :capture => :out)
 
             # 检查是否有冲突
             conflict_filelist = git!(%W(-C #{current_project_dir} diff --name-only --diff-filter=U --relative))
             if !conflict_filelist.nil? && !conflict_filelist.strip.empty?
-              raise Informative, "合并#{coding_branch}到#{release_branch}时产生冲突，请手动处理！"
+              raise Informative, "合并#{source_branch}到#{target_branch}时产生冲突，请手动处理！"
             else
               git!(%W(-C #{current_project_dir} push))
-              Funlog.instance.fancyinfo_success("代码已经合并到#{release_branch}分支")
-              # 获取 release_branch 的 commit ID（处理空分支情况）
+              Funlog.instance.fancyinfo_success("代码已经合并到#{target_branch}分支")
+              # 获取 target_branch 的 commit ID（处理空分支情况）
               begin
-                release_branch_commit_id = git!(%W(-C #{current_project_dir} rev-parse #{release_branch})).strip
+                target_branch_commit_id = git!(%W(-C #{current_project_dir} rev-parse #{target_branch})).strip
               rescue => e
-                # 分支可能存在但没有提交（空分支），此时使用 coding_branch 的 commit
-                Funlog.instance.fancyinfo_update("#{release_branch}分支为空或获取commit失败，将使用当前分支commit")
-                release_branch_commit_id = coding_branch_commit_id
+                # 分支可能存在但没有提交（空分支），此时使用 source_branch 的 commit
+                Funlog.instance.fancyinfo_update("#{target_branch}分支为空或获取commit失败，将使用当前分支commit")
+                target_branch_commit_id = source_branch_commit_id
               end
             end
 
           else
-            if local_branch_exists?(local_repo_dir: current_project_dir, branch: release_branch)
-              Funlog.instance.fancyinfo_update("不存在#{release_branch}远程分支")
-              Funlog.instance.fancyinfo_update("存在#{release_branch}本地分支")
-              git!(%W(-C #{current_project_dir} checkout #{release_branch}))
+            if local_branch_exists?(local_repo_dir: current_project_dir, branch: target_branch)
+              Funlog.instance.fancyinfo_update("不存在#{target_branch}远程分支")
+              Funlog.instance.fancyinfo_update("存在#{target_branch}本地分支")
+              git!(%W(-C #{current_project_dir} checkout #{target_branch}))
               # 使用带时间戳的备份分支名，避免重复操作时冲突
-              backup_branch = "#{release_branch}_backup_#{Time.now.strftime('%Y%m%d%H%M%S')}"
+              backup_branch = "#{target_branch}_backup_#{Time.now.strftime('%Y%m%d%H%M%S')}"
               Funlog.instance.fancyinfo_update("备份本地分支到: #{backup_branch}")
               git!(%W(-C #{current_project_dir} checkout -b #{backup_branch}))
-              git!(%W(-C #{current_project_dir} checkout #{coding_branch}))
-              git!(%W(-C #{current_project_dir} branch -D #{release_branch}))
+              git!(%W(-C #{current_project_dir} checkout #{source_branch}))
+              git!(%W(-C #{current_project_dir} branch -D #{target_branch}))
             else
-              Funlog.instance.fancyinfo_update("不存在#{release_branch}远程分支")
-              Funlog.instance.fancyinfo_update("不存在#{release_branch}本地分支")
+              Funlog.instance.fancyinfo_update("不存在#{target_branch}远程分支")
+              Funlog.instance.fancyinfo_update("不存在#{target_branch}本地分支")
             end
 
-            git!(%W(-C #{current_project_dir} checkout -b #{release_branch}))
-            git!(%W(-C #{current_project_dir} push origin #{release_branch}))
-            git!(%W(-C #{current_project_dir} branch --set-upstream-to=origin/#{release_branch} #{release_branch}))
+            # 基于 source_branch 创建 target_branch（明确指定起点，避免基于错误的分支创建）
+            git!(%W(-C #{current_project_dir} checkout -b #{target_branch} #{source_branch}))
+            git!(%W(-C #{current_project_dir} push origin #{target_branch}))
+            git!(%W(-C #{current_project_dir} branch --set-upstream-to=origin/#{target_branch} #{target_branch}))
 
-            Funlog.instance.fancyinfo_success("代码已经合并到#{release_branch}分支")
-            # 获取 release_branch 的 commit ID（处理空分支情况）
+            Funlog.instance.fancyinfo_success("代码已经合并到#{target_branch}分支")
+            # 获取 target_branch 的 commit ID（处理空分支情况）
             begin
-              release_branch_commit_id = git!(%W(-C #{current_project_dir} rev-parse #{release_branch})).strip
+              target_branch_commit_id = git!(%W(-C #{current_project_dir} rev-parse #{target_branch})).strip
             rescue => e
-              # 新创建的分支，commit ID 应该与 coding_branch 相同
-              release_branch_commit_id = coding_branch_commit_id
+              # 新创建的分支，commit ID 应该与 source_branch 相同
+              target_branch_commit_id = source_branch_commit_id
             end
           end
 
-          git!(%W(-C #{current_project_dir} checkout #{coding_branch}))
-          if release_branch_commit_id && !release_branch_commit_id.eql?(coding_branch_commit_id)
-            Executable.capture_command('git', %W(-C #{current_project_dir} merge #{release_branch}), :capture => :out)
-            conflict_filelist = git!(%W(-C #{current_project_dir} diff --name-only --diff-filter=U --relative))
-            if !conflict_filelist.nil? && !conflict_filelist.strip.empty?
-              raise Informative, "合并#{release_branch}到#{coding_branch}时产生冲突，请手动处理！"
+          # 同步分支：将 source_branch 同步到 target_branch（确保两分支在同一节点）
+          git!(%W(-C #{current_project_dir} checkout #{source_branch}))
+          if sync_branches
+            if target_branch_commit_id && !target_branch_commit_id.eql?(source_branch_commit_id)
+              # 检查是否可以 fast-forward（即 source_branch 是 target_branch 的祖先）
+              is_ancestor = false
+              begin
+                git!(%W(-C #{current_project_dir} merge-base --is-ancestor #{source_branch} #{target_branch}))
+                is_ancestor = true
+              rescue => e
+                # 不是祖先关系，说明 source_branch 有独立提交（理论上不应该，因为刚合并过）
+                Funlog.instance.fancyinfo_warning("#{source_branch} 不是 #{target_branch} 的祖先")
+              end
+
+              if is_ancestor
+                # 可以安全 fast-forward（source 的所有提交都在 target 中）
+                Funlog.instance.fancyinfo_update("#{source_branch}是#{target_branch}的祖先，执行 fast-forward 合并")
+                begin
+                  # 尝试 fast-forward only merge（确保不产生新 commit）
+                  git!(%W(-C #{current_project_dir} merge --ff-only #{target_branch}))
+                  Funlog.instance.fancyinfo_success("已将#{source_branch} fast-forward 到#{target_branch}，两分支现在在同一节点")
+
+                  # 推送到远程（普通 push，因为是 fast-forward）
+                  git!(%W(-C #{current_project_dir} push origin #{source_branch}))
+                  Funlog.instance.fancyinfo_success("已推送#{source_branch}分支到远程")
+                rescue => e
+                  if e.message.include?("Not possible to fast-forward")
+                    # 理论上不应该到这里，因为前面检查过是祖先
+                    Funlog.instance.fancyinfo_warning("无法 fast-forward，将产生 merge commit")
+                    git!(%W(-C #{current_project_dir} merge #{target_branch}))
+                    git!(%W(-C #{current_project_dir} push origin #{source_branch}))
+                  else
+                    raise e
+                  end
+                end
+              else
+                # 不是祖先关系，使用普通 merge（会产生新的 merge commit）
+                Funlog.instance.fancyinfo_warning("#{source_branch}不是#{target_branch}的祖先，将执行普通合并（可能产生新 commit）")
+                Executable.capture_command('git', %W(-C #{current_project_dir} merge #{target_branch}), :capture => :out)
+
+                # 检查冲突
+                conflict_filelist = git!(%W(-C #{current_project_dir} diff --name-only --diff-filter=U --relative))
+                if !conflict_filelist.nil? && !conflict_filelist.strip.empty?
+                  raise Informative, "合并#{target_branch}到#{source_branch}时产生冲突，请手动处理！"
+                end
+
+                git!(%W(-C #{current_project_dir} push origin #{source_branch}))
+                Funlog.instance.fancyinfo_success("已将#{target_branch}合并到#{source_branch}（产生了新 merge commit）")
+              end
+            else
+              Funlog.instance.fancyinfo_success("#{source_branch}和#{target_branch}已经在同一节点，无需同步")
             end
-            Funlog.instance.fancyinfo_success("已将#{release_branch}合并到#{coding_branch}")
+          else
+            Funlog.instance.fancyinfo_success("单向合并完成，未同步 #{target_branch} 到 #{source_branch}")
           end
-          git!(%W(-C #{current_project_dir} push origin #{coding_branch}))
-          Funlog.instance.fancyinfo_success("已推送#{coding_branch}分支到远程")
         else
-          Funlog.instance.fancyinfo_success("代码处于#{coding_branch}分支,无需合并")
+          Funlog.instance.fancyinfo_success("代码处于#{source_branch}分支,无需合并")
         end
       end
 
-      # 检查并推送未推送的本地提交
+      # 检查并推送未推送的本地提交，确保本地和远程分支完全同步
       # @param project_dir [String] 项目目录路径
       # @param branch [String] 分支名称
       # @return [void]
@@ -976,20 +1027,44 @@ module Pindo
           return
         end
 
-        # 3. 检查本地分支是否领先远程分支
+        # 3. 先 fetch 获取最新的远程状态
+        git!(%W(-C #{project_dir} fetch origin #{branch}))
+
+        # 4. 检查本地分支是否领先远程分支
         ahead_count = git!(%W(-C #{project_dir} rev-list --count #{remote_branch}..#{branch})).strip.to_i
 
-        # 4. 如果没有未推送的提交，直接返回
-        if ahead_count == 0
-          Funlog.instance.fancyinfo_success("本地分支 #{branch} 与远程分支同步，无需推送")
+        # 5. 检查远程分支是否领先本地分支
+        behind_count = git!(%W(-C #{project_dir} rev-list --count #{branch}..#{remote_branch})).strip.to_i
+
+        # 6. 根据同步状态执行相应操作
+        if ahead_count == 0 && behind_count == 0
+          Funlog.instance.fancyinfo_success("本地分支 #{branch} 与远程分支完全同步")
           return
-        end
+        elsif ahead_count > 0 && behind_count == 0
+          # 仅本地领先：直接推送
+          Funlog.instance.fancyinfo_warning("检测到 #{ahead_count} 个本地提交尚未推送")
+          Funlog.instance.fancyinfo_start("正在推送到远程分支 #{remote_branch}...")
+          git!(%W(-C #{project_dir} push origin #{branch}))
+          Funlog.instance.fancyinfo_success("推送成功!")
+        elsif ahead_count == 0 && behind_count > 0
+          # 仅远程领先：重置本地到远程位置
+          Funlog.instance.fancyinfo_warning("远程分支领先本地 #{behind_count} 个提交")
+
+          # 检查工作目录是否干净
+          status = git!(%W(-C #{project_dir} status --porcelain)).strip
+          unless status.empty?
+            raise Informative, "工作目录有未提交的修改，无法同步远程更新。请先提交或 stash 修改。"
+          end
 
-        # 5. 有未推送的提交，直接推送（不显示内容，不询问用户）
-        Funlog.instance.fancyinfo_warning("检测到 #{ahead_count} 个本地提交尚未推送")
-        Funlog.instance.fancyinfo_start("正在推送到远程分支 #{remote_branch}...")
-        git!(%W(-C #{project_dir} push origin #{branch}))
-        Funlog.instance.fancyinfo_success("推送成功!")
+          # 工作目录干净，安全地重置到远程位置
+          Funlog.instance.fancyinfo_start("正在重置本地分支到远程位置...")
+          git!(%W(-C #{project_dir} reset --hard #{remote_branch}))
+          Funlog.instance.fancyinfo_success("已同步到远程分支!")
+        else
+          # 分叉：需要合并
+          Funlog.instance.fancyinfo_warning("本地和远程分支已分叉：本地领先 #{ahead_count} 个提交，远程领先 #{behind_count} 个提交")
+          raise Informative, "本地分支和远程分支已分叉，请手动合并或变基后再继续！"
+        end
       end
 
     end

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/android/autobuild.rb

@@ -33,44 +33,62 @@ module Pindo
         self.description = <<-DESC
             编译Android工程生成APK/AAB并支持上传到JPS测试平台。
 
-            支持功能:
+            参数优先级说明（从低到高）:
 
-                * 自动修改工程配置（Application ID、App Name、URL Schemes）
+                1. 无参数：
+                   - Git 提交 → 编译 APK → 打 Git Tag
 
-                * 编译生成APK或AAB文件
+                2. --upload：
+                   - 在基础流程上增加：上传 APK → 发送消息给自己
 
-                * 支持上传到JPS测试平台
+                3. --media：
+                   - 自动启用 --upload
+                   - 在 --upload 基础上增加：上传媒体附件（JPSMedia/ 目录）
 
-                * 支持发送测试通知
+                4. --bind：
+                   - 自动启用 --media 和 --upload
+                   - 在 --media 基础上增加：绑定 Git commit 到已上传的包
 
-                * 支持Unity和原生Android工程
+                5. --send：
+                   - 自动启用 --bind、--media 和 --upload
+                   - 在 --bind 基础上增加：发送工作流消息到测试群
+
+            支持功能:
 
+                * 自动修改工程配置（Application ID、App Name、URL Schemes）
+                * 编译生成 APK 或 AAB 文件
+                * 上传到 JPS 测试平台
+                * 上传媒体附件（图片、视频）
+                * 绑定 Git commit 到已上传的包
+                * 发送测试通知（自己/测试群）
+                * 支持 Unity 和原生 Android 工程
                 * 支持并发任务执行（使用 --multi 参数）
 
             使用示例:
 
-                $ pindo android autobuild                    # 编译Debug包
+                $ pindo and autobuild --bundle_name=com.example.app  # 指定 Bundle Name
 
-                $ pindo android autobuild --release          # 编译Release包
+                $ pindo and autobuild --proj="My App"           # 指定项目名称
 
-                $ pindo android autobuild --upload           # 编译并上传到JPS
+                $ pindo and autobuild                           # 编译、打tag
 
-                $ pindo android autobuild --send             # 编译、上传并发送群组通知
+                $ pindo and autobuild --release                 # 编译 Release 包
 
-                $ pindo android autobuild --media            # 编译、上传并上传媒体附件
+                $ pindo and autobuild --upload                  # 编译、打tag、上传、发上传消息
 
-                $ pindo android autobuild --bundle_name=com.example.app  # 使用指定bundle name的配置
+                $ pindo and autobuild --media                   # 编译、打tag、上传、发上传消息、上传媒体附件
 
-                $ pindo android autobuild --proj="My App"    # 指定项目名称
+                $ pindo and autobuild --bind                    # 编译、打tag、上传、发上传消息、上传媒体附件 + 绑定包到工作流
 
-                $ pindo android autobuild --multi            # 使用并发模式执行（速度更快）
+                $ pindo and autobuild --send                    # 编译、打tag、上传、发上传消息、上传媒体附件、绑定包到工作流 + 发送群消息
 
-                $ pindo android autobuild --multi --upload   # 并发执行并上传
+                $ pindo and autobuild --multi                   # 使用并发模式执行
         DESC
 
         # 定义此命令使用的参数项
         def self.option_items
           @option_items ||= Pindo::Options::OptionGroup.merge(
+            Pindo::Options::BuildOptions.select(:bundle_name),  # 添加 bundle_name 参数
             Pindo::Options::JPSOptions.select(:proj, :upload, :send, :media),
             Pindo::Options::UnityOptions.select(:skiplib, :skipyoo),
             Pindo::Options::UnityOptions.select_with_defaults(skipconfig: true),
@@ -81,8 +99,7 @@ module Pindo
 
         def self.options
           [
-            ['--release',     '使用Release模式构建'],
-            ['--bundle_name=NAME', '指定Android Package Name（如com.example.app，会拉取对应配置）']
+            ['--release',     '使用Release模式构建']
           ].concat(option_items.map(&:to_claide_option)).concat(super)
         end
 
@@ -90,14 +107,23 @@ module Pindo
           @options = initialize_options(argv)
 
           @args_release_flag = argv.flag?('release', false)
-          @args_upload_flag = @options[:upload] || false
-          @args_send_flag = @options[:send] || false
           @args_proj_name = @options[:proj]
-          @args_bundle_name = argv.option('bundle_name')
+          @args_bundle_name = @options[:bundle_name]  # 从 @options 获取，确保能被缓存
+
+          # send、media 或 bind 都依赖 upload：如果指定了任一参数，自动启用 upload
+          @args_upload_flag = @options[:send] || @options[:bind] || @options[:media] || @options[:upload]
+
+          # media 任务是独立的，不依赖任何其他任务，但是为输入命令参数更加简单，如果有--bind和--send， 则默认认为一定会有--media参数
+          @args_media_flag = @options[:send] || @options[:bind] || @options[:media] || false
+
+          # send 都依赖 bind：如果指定了任一参数，自动启用 bind
+          @args_bind_flag = @options[:send] || @options[:bind] || false
+
+          @args_send_flag = @options[:send]
+
+          # Unity 参数
           @args_skip_lib = @options[:skiplib] || false
           @args_skip_yoo = @options[:skipyoo] || false
-          # media 依赖 upload：如果指定了 media，自动启用 upload
-          @args_media_flag = @options[:media] || false
 
           # Task 参数
           @args_multi_flag = @options[:multi] || false
@@ -108,10 +134,6 @@ module Pindo
           @args_tag_type = Pindo::Options::GitOptions.parse_create_tag_type(@options[:tag_type] || 'new')
           @args_tag_pre = @options[:tag_pre] || 'v'
 
-          if @args_send_flag || @args_media_flag
-            @args_upload_flag = true
-          end
-
           super
           @additional_args = argv.remainder!
         end
@@ -150,6 +172,12 @@ module Pindo
           # 获取 Bundle Name
           bundle_name = @args_bundle_name || get_selected_dev_bundle_name()
 
+          # 重要：如果 bundle_name 是通过交互式选择获取的，同步回 @options
+          if bundle_name && (@args_bundle_name.nil? || @args_bundle_name.empty?)
+            @args_bundle_name = bundle_name
+            @options[:bundle_name] = bundle_name  # 确保能被缓存系统保存
+          end
+
           # 获取 JPS 配置
           app_info_obj, workflow_info = PgyerHelper.share_instace.prepare_upload(
             working_directory: pindo_project_dir,
@@ -256,8 +284,6 @@ module Pindo
               project_path: android_project_path,
               bundle_name: config[:bundle_name],
               proj_name: @args_proj_name,
-              upload: @args_upload_flag,
-              send: @args_send_flag,
               app_info_obj: config[:app_info_obj],
               workflow_info: config[:workflow_info],
               # Git 版本参数
@@ -283,6 +309,7 @@ module Pindo
             tasks << git_tag_task
 
             # 5. 上传和消息发送任务（如果需要）
+            upload_task = nil  # 声明变量以便后续绑定任务使用
             if @args_upload_flag
               # 5.1 创建上传任务
               upload_task = Pindo::TaskSystem::JPSUploadTask.new(
@@ -296,15 +323,15 @@ module Pindo
               upload_task.dependencies << build_task.id
               tasks << upload_task
 
-              # 5.2 创建消息发送任务（只依赖上传任务）
+              # 5.2 创建消息发送任务（只依赖上传任务，固定发送给自己）
               # app_version_info 将从 upload_task 的数据参数中获取
               message_task = Pindo::TaskSystem::JPSMessageTask.new(
                 nil,  # app_version_info 为 nil，从依赖任务获取
                 app_info_obj: config[:app_info_obj],
                 project_name: @args_proj_name,
-                send_message_type: @args_send_flag ? 'group' : 'self',
-                dependencies: [upload_task.id]  # 从 upload_task 获取数据
+                send_message_type: 'self'  # 固定发送给自己
               )
+              message_task.dependencies << upload_task.id
               tasks << message_task
             end
 
@@ -325,11 +352,52 @@ module Pindo
                 workflow_info: git_workflow_info,
                 project_name: @args_proj_name
               )
-              # 只依赖 Git 提交任务
+              # 依赖 Git 提交任务
               media_upload_task.dependencies << git_commit_task.id
               tasks << media_upload_task
             end
 
+            # 7. 创建 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],
+                project_name: @args_proj_name
+              )
+              # 依赖上传任务和 Git 提交任务
+              bind_package_task.dependencies << upload_task.id
+              bind_package_task.dependencies << git_commit_task.id
+              tasks << bind_package_task
+            end
+
+            # 8. 创建工作流消息任务（如果需要，发送到测试群）
+            if @args_send_flag
+              # 获取 Git 工作流信息
+              git_app_info_obj, git_workflow_info = PgyerHelper.share_instace.prepare_upload(
+                working_directory: config[:project_path],
+                proj_name: @args_proj_name,
+                package_type: "",
+                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',
+                single: true,
+                app_info_obj: git_app_info_obj,
+                workflow_info: git_workflow_info
+              )
+              # 依赖 Git Commit、Git Tag 和 Bind Package 任务
+              workflow_message_task.dependencies << git_commit_task.id
+              workflow_message_task.dependencies << git_tag_task.id
+              workflow_message_task.dependencies << bind_package_task.id
+              tasks << workflow_message_task
+            end
+
             tasks
           else
             raise Informative, "当前目录不是工程目录，不能编译"

data/lib/pindo/command/appstore/bundleid.rb

@@ -55,7 +55,7 @@ module Pindo
                         Pindo::Options::OptionItem.new(
                             key: :sign,
                             description: '启用签名标志',
-                            type: TrueClass,
+                            type: :boolean,
                             optional: true,
                             default_value: false,
                             example: 'pindo appstore bundleid --sign'

data/lib/pindo/command/appstore/pem.rb

@@ -61,7 +61,7 @@ module Pindo
                         Pindo::Options::OptionItem.new(
                             key: :dev,
                             description: '创建开发环境证书（默认为生产环境）',
-                            type: TrueClass,
+                            type: :boolean,
                             optional: true,
                             default_value: false,
                             example: 'pindo appstore pem --dev'