pindo 5.5.8 → 5.6.2

data/lib/pindo/module/android/gradle_helper.rb

@@ -264,88 +264,53 @@ module Pindo
       end
     end
 
-    # 生成gradle-wrapper.jar（使用gradle wrapper命令）
+    # 改进的生成gradle-wrapper.jar逻辑（带缓存和内置文件回退）
     def download_gradle_wrapper_jar(wrapper_dir, gradle_version)
       wrapper_jar_path = File.join(wrapper_dir, "gradle-wrapper.jar")
       
-      # 如果已存在且版本匹配，跳过生成
-      if File.exist?(wrapper_jar_path) && verify_gradle_wrapper_jar(wrapper_jar_path, gradle_version)
-        puts "\e[32m✓ gradle-wrapper.jar已存在且版本匹配\e[0m"
+      # 1. 检查现有文件是否有效
+      if File.exist?(wrapper_jar_path) && verify_gradle_wrapper_jar_complete(wrapper_jar_path, gradle_version)
+        puts "\e[32m✓ gradle-wrapper.jar已存在且验证通过\e[0m"
         return true
       end
 
       puts "正在生成gradle-wrapper.jar (版本: #{gradle_version})..."
       
-      # 获取项目根目录
-      project_path = File.dirname(File.dirname(wrapper_dir))
-      
-      # 检查是否有gradlew脚本
-      gradlew_path = File.join(project_path, "gradlew")
-      
-      if File.exist?(gradlew_path)
-        puts "发现gradlew脚本，使用gradle wrapper命令生成..."
-        return generate_wrapper_with_gradlew(project_path, gradle_version)
-      else
-        puts "未发现gradlew脚本，使用gradle命令生成..."
-        return generate_wrapper_with_gradle(project_path, gradle_version)
-      end
-    end
-
-    # 使用gradlew脚本生成wrapper
-    def generate_wrapper_with_gradlew(project_path, gradle_version)
-      puts "使用gradlew脚本生成wrapper..."
-      
-      # 切换到项目目录
-      Dir.chdir(project_path) do
-        # 使用gradlew wrapper命令生成wrapper
-        cmd = "./gradlew wrapper --gradle-version #{gradle_version}"
-        puts "执行命令: #{cmd}"
-        
-        result = system(cmd)
-        if result
-          puts "\e[32m✓ gradle wrapper生成成功\e[0m"
+      # 2. 尝试使用缓存
+      cached_jar = get_cached_gradle_wrapper_jar(gradle_version)
+      if cached_jar
+        FileUtils.cp(cached_jar, wrapper_jar_path)
+        # 验证缓存文件
+        if verify_gradle_wrapper_jar_complete(wrapper_jar_path, gradle_version)
+          puts "\e[32m✓ 从缓存复制 gradle-wrapper.jar 成功\e[0m"
           return true
         else
-          puts "\e[31m✗ gradle wrapper生成失败\e[0m"
-          return false
+          puts "\e[33m⚠ 缓存文件验证失败，继续下载\e[0m"
         end
       end
-    rescue => e
-      puts "\e[31m✗ gradle wrapper生成异常: #{e.message}\e[0m"
-      false
-    end
-
-    # 使用gradle命令生成wrapper
-    def generate_wrapper_with_gradle(project_path, gradle_version)
-      puts "使用gradle命令生成wrapper..."
-      
-      # 检查系统是否有gradle命令
-      unless system("which gradle > /dev/null 2>&1")
-        puts "\e[33m⚠ 系统未安装gradle，使用简化的wrapper生成方式...\e[0m"
-        return generate_wrapper_manually(project_path, gradle_version)
-      end
       
-      # 切换到项目目录
-      Dir.chdir(project_path) do
-        # 使用gradle wrapper命令生成wrapper
-        cmd = "gradle wrapper --gradle-version #{gradle_version}"
-        puts "执行命令: #{cmd}"
-        
-        result = system(cmd)
-        if result
-          puts "\e[32m✓ gradle wrapper生成成功\e[0m"
+      # 3. 尝试下载
+      if download_standard_wrapper_jar(wrapper_jar_path, gradle_version)
+        # 验证下载的文件
+        if verify_gradle_wrapper_jar_complete(wrapper_jar_path, gradle_version)
           return true
         else
-          puts "\e[31m✗ gradle wrapper生成失败\e[0m"
-          return false
+          puts "\e[33m⚠ 下载文件验证失败，使用内置文件\e[0m"
         end
       end
-    rescue => e
-      puts "\e[31m✗ gradle wrapper生成异常: #{e.message}\e[0m"
+      
+      # 4. 最后回退：使用内置文件
+      puts "\e[33m⚠ 所有下载源失败，使用内置 gradle-wrapper.jar\e[0m"
+      if use_builtin_gradle_wrapper_jar(wrapper_jar_path, gradle_version)
+        return true
+      end
+      
+      puts "\e[31m✗ 无法获取有效的 gradle-wrapper.jar\e[0m"
       false
     end
 
-    # 手动生成wrapper（不使用临时目录）
+
+    # 改进的手动生成wrapper逻辑（带内置文件回退）
     def generate_wrapper_manually(project_path, gradle_version)
       puts "手动生成gradle wrapper..."
       
@@ -353,20 +318,24 @@ module Pindo
       wrapper_dir = File.join(project_path, "gradle/wrapper")
       FileUtils.mkdir_p(wrapper_dir)
       
-      # 生成gradlew脚本
+      # 1. 生成gradlew脚本（带内置文件回退）
       gradlew_path = File.join(project_path, "gradlew")
       unless File.exist?(gradlew_path)
         puts "生成gradlew脚本..."
-        generate_gradlew_script(project_path)
+        unless generate_gradlew_script(project_path)
+          puts "\e[31m✗ 生成gradlew脚本失败\e[0m"
+          return false
+        end
       end
       
-      # 生成gradle-wrapper.jar（使用预定义的jar文件）
+      # 2. 生成gradle-wrapper.jar（带缓存和内置文件回退）
       wrapper_jar_path = File.join(wrapper_dir, "gradle-wrapper.jar")
       unless File.exist?(wrapper_jar_path)
         puts "生成gradle-wrapper.jar..."
-        # 这里可以使用一个通用的gradle-wrapper.jar文件
-        # 或者从网络下载一个标准的jar文件
-        return download_standard_wrapper_jar(wrapper_jar_path, gradle_version)
+        unless download_gradle_wrapper_jar(wrapper_dir, gradle_version)
+          puts "\e[31m✗ 生成gradle-wrapper.jar失败\e[0m"
+          return false
+        end
       end
       
       puts "\e[32m✓ gradle wrapper手动生成成功\e[0m"
@@ -376,120 +345,248 @@ module Pindo
       false
     end
 
-    # 下载标准的gradle-wrapper.jar
+    # 获取缓存目录路径
+    def get_gradle_wrapper_cache_dir
+      File.expand_path("~/.pindo/pindo_common_config/android_tools/gradle-wrapper-cache")
+    end
+
+    # 获取内置文件路径
+    def get_builtin_gradle_wrapper_jar_path
+      File.expand_path("~/.pindo/pindo_common_config/android_tools/gradle-wrapper.jar")
+    end
+
+    def get_builtin_gradlew_path
+      File.expand_path("~/.pindo/pindo_common_config/android_tools/gradlew")
+    end
+
+    # 检查并获取缓存的 gradle-wrapper.jar
+    def get_cached_gradle_wrapper_jar(gradle_version)
+      cache_dir = get_gradle_wrapper_cache_dir
+      FileUtils.mkdir_p(cache_dir)
+      
+      cached_jar = File.join(cache_dir, "gradle-wrapper-#{gradle_version}.jar")
+      
+      if File.exist?(cached_jar) && verify_gradle_wrapper_jar_complete(cached_jar, gradle_version)
+        puts "\e[32m✓ 使用缓存的 gradle-wrapper.jar (版本: #{gradle_version})\e[0m"
+        return cached_jar
+      end
+      
+      nil
+    end
+
+    # 增强的 gradle-wrapper.jar 验证
+    def verify_gradle_wrapper_jar_complete(jar_path, expected_version)
+      return false unless File.exist?(jar_path)
+      
+      # 检查文件大小（正常应该在 50KB-200KB 之间）
+      file_size = File.size(jar_path)
+      unless file_size.between?(50000, 200000)
+        puts "\e[33m⚠ gradle-wrapper.jar 大小异常: #{file_size} 字节\e[0m"
+        return false
+      end
+      
+      # 检查 jar 文件是否包含必要的类
+      required_classes = [
+        "org.gradle.wrapper.GradleWrapperMain",
+        "org.gradle.cli.CommandLineParser",
+        "org.gradle.wrapper.WrapperExecutor"
+      ]
+      
+      missing_classes = []
+      required_classes.each do |class_name|
+        unless verify_jar_contains_class(jar_path, class_name)
+          missing_classes << class_name
+        end
+      end
+      
+      if missing_classes.any?
+        puts "\e[33m⚠ gradle-wrapper.jar 缺少必要类: #{missing_classes.join(', ')}\e[0m"
+        return false
+      end
+      
+      puts "\e[32m✓ gradle-wrapper.jar 验证通过\e[0m"
+      true
+    end
+
+    # 检查 jar 文件是否包含指定类
+    def verify_jar_contains_class(jar_path, class_name)
+      class_file = class_name.gsub('.', '/') + '.class'
+      system("jar -tf #{jar_path} | grep -q '#{class_file}'")
+    end
+
+    # 使用内置的 gradle-wrapper.jar
+    def use_builtin_gradle_wrapper_jar(wrapper_jar_path, gradle_version)
+      builtin_jar = get_builtin_gradle_wrapper_jar_path
+      
+      unless File.exist?(builtin_jar)
+        puts "\e[31m✗ 内置 gradle-wrapper.jar 不存在: #{builtin_jar}\e[0m"
+        return false
+      end
+      
+      # 复制内置文件
+      FileUtils.cp(builtin_jar, wrapper_jar_path)
+      puts "\e[33m⚠ 使用内置的 gradle-wrapper.jar\e[0m"
+      
+      # 验证复制后的文件
+      if verify_gradle_wrapper_jar_complete(wrapper_jar_path, gradle_version)
+        puts "\e[32m✓ 内置 gradle-wrapper.jar 验证通过\e[0m"
+        return true
+      else
+        puts "\e[31m✗ 内置 gradle-wrapper.jar 验证失败\e[0m"
+        return false
+      end
+    end
+
+    # 使用内置的 gradlew 脚本
+    def use_builtin_gradlew_script(project_path)
+      builtin_gradlew = get_builtin_gradlew_path
+      gradlew_path = File.join(project_path, "gradlew")
+      
+      unless File.exist?(builtin_gradlew)
+        puts "\e[31m✗ 内置 gradlew 脚本不存在: #{builtin_gradlew}\e[0m"
+        return false
+      end
+      
+      # 复制内置脚本
+      FileUtils.cp(builtin_gradlew, gradlew_path)
+      system("chmod", "+x", gradlew_path)
+      puts "\e[33m⚠ 使用内置的 gradlew 脚本\e[0m"
+      puts "\e[32m✓ 内置 gradlew 脚本复制完成\e[0m"
+      true
+    end
+
+    # 保存到缓存的 gradle-wrapper.jar
+    def save_to_cache(wrapper_jar_path, gradle_version)
+      cache_dir = get_gradle_wrapper_cache_dir
+      FileUtils.mkdir_p(cache_dir)
+      
+      cached_jar = File.join(cache_dir, "gradle-wrapper-#{gradle_version}.jar")
+      FileUtils.cp(wrapper_jar_path, cached_jar)
+      puts "\e[32m✓ gradle-wrapper.jar 已保存到缓存: #{cached_jar}\e[0m"
+    end
+
+    # 改进的下载标准 gradle-wrapper.jar（使用正确的下载策略）
     def download_standard_wrapper_jar(wrapper_jar_path, gradle_version)
       puts "下载标准的gradle-wrapper.jar..."
       
-      # 使用gradle官方提供的wrapper jar下载URL
-      wrapper_jar_urls = [
-        "https://github.com/gradle/gradle/raw/v#{gradle_version}/gradle/wrapper/gradle-wrapper.jar",
-        "https://raw.githubusercontent.com/gradle/gradle/v#{gradle_version}/gradle/wrapper/gradle-wrapper.jar"
+      # 使用正确的下载策略：从Gradle分发包中提取wrapper jar
+      gradle_dist_urls = [
+        "https://services.gradle.org/distributions/gradle-#{gradle_version}-bin.zip"
       ]
       
-      wrapper_jar_urls.each do |url|
-        puts "尝试下载: #{url}"
-        if download_with_curl(url, wrapper_jar_path)
-          if File.exist?(wrapper_jar_path) && File.size(wrapper_jar_path) > 1000
-            puts "\e[32m✓ gradle-wrapper.jar下载成功\e[0m"
-            return true
-          end
+      gradle_dist_urls.each do |url|
+        puts "尝试从Gradle分发包下载: #{url}"
+        if download_and_extract_wrapper_from_distribution(url, wrapper_jar_path, gradle_version)
+          puts "\e[32m✓ 从Gradle分发包成功提取gradle-wrapper.jar\e[0m"
+          # 保存到缓存
+          save_to_cache(wrapper_jar_path, gradle_version)
+          return true
         end
       end
       
-      puts "\e[31m✗ 下载gradle-wrapper.jar失败\e[0m"
+      
+      puts "\e[31m✗ 下载 gradle-wrapper.jar 失败\e[0m"
       false
     end
 
-    # 下载gradle分发包并生成wrapper
-    def download_and_generate_wrapper(project_path, gradle_version)
-      puts "下载gradle分发包并生成wrapper..."
-      
+    # 从Gradle分发包中下载并提取wrapper jar
+    def download_and_extract_wrapper_from_distribution(dist_url, wrapper_jar_path, gradle_version)
       begin
         # 创建临时目录
-        temp_dir = Dir.mktmpdir("gradle_download_")
+        temp_dir = Dir.mktmpdir("gradle_dist_")
+        zip_path = File.join(temp_dir, "gradle-#{gradle_version}-bin.zip")
+        
+        # 下载Gradle分发包
+        puts "下载Gradle分发包: #{dist_url}"
+        unless download_with_curl(dist_url, zip_path)
+          puts "\e[33m⚠ 下载Gradle分发包失败\e[0m"
+          return false
+        end
+        
+        # 检查下载的文件大小
+        unless File.exist?(zip_path) && File.size(zip_path) > 1000000  # 至少1MB
+          puts "\e[33m⚠ 下载的Gradle分发包文件异常\e[0m"
+          return false
+        end
+        
+        # 解压Gradle分发包
+        puts "解压Gradle分发包..."
+        unless system("cd #{temp_dir} && unzip -q gradle-#{gradle_version}-bin.zip")
+          puts "\e[33m⚠ 解压Gradle分发包失败\e[0m"
+          return false
+        end
+        
+        # 查找gradle-wrapper jar文件
         gradle_dir = File.join(temp_dir, "gradle-#{gradle_version}")
+        wrapper_jar_source = File.join(gradle_dir, "lib", "gradle-wrapper-#{gradle_version}.jar")
+        
+        unless File.exist?(wrapper_jar_source)
+          puts "\e[33m⚠ 在Gradle分发包中未找到gradle-wrapper jar文件\e[0m"
+          return false
+        end
         
-        # 下载gradle分发包
-        download_urls = [
-          "https://services.gradle.org/distributions/gradle-#{gradle_version}-bin.zip",
-          "https://github.com/gradle/gradle-distributions/releases/download/v#{gradle_version}/gradle-#{gradle_version}-bin.zip"
-        ]
+        # 解压gradle-wrapper jar文件，提取真正的gradle-wrapper.jar
+        extract_temp_dir = Dir.mktmpdir("gradle_wrapper_extract_")
+        extract_cmd = "cd #{extract_temp_dir} && unzip -q '#{wrapper_jar_source}'"
         
-        download_success = false
-        download_urls.each do |url|
-          puts "尝试下载: #{url}"
-          zip_path = File.join(temp_dir, "gradle-#{gradle_version}-bin.zip")
-          
-          if download_with_curl(url, zip_path)
-            # 解压gradle分发包
-            if system("cd #{temp_dir} && unzip -q gradle-#{gradle_version}-bin.zip")
-              download_success = true
-              puts "✓ gradle分发包下载并解压成功"
-              break
-            end
-          end
+        unless system(extract_cmd)
+          puts "\e[33m⚠ 解压gradle-wrapper jar文件失败\e[0m"
+          FileUtils.rm_rf(extract_temp_dir)
+          return false
         end
         
-        unless download_success
-          puts "\e[31m✗ 下载gradle分发包失败\e[0m"
+        # 查找解压后的gradle-wrapper.jar文件
+        extracted_wrapper_jar = File.join(extract_temp_dir, "gradle-wrapper.jar")
+        
+        unless File.exist?(extracted_wrapper_jar)
+          puts "\e[33m⚠ 在解压后的文件中未找到gradle-wrapper.jar\e[0m"
+          FileUtils.rm_rf(extract_temp_dir)
           return false
         end
         
-        # 使用下载的gradle生成wrapper
-        gradle_bin = File.join(gradle_dir, "bin", "gradle")
-        if File.exist?(gradle_bin)
-          Dir.chdir(project_path) do
-            cmd = "#{gradle_bin} wrapper --gradle-version #{gradle_version}"
-            puts "执行命令: #{cmd}"
-            
-            result = system(cmd)
-            if result
-              puts "\e[32m✓ gradle wrapper生成成功\e[0m"
-              # 重要：在清理临时目录之前，确保wrapper已经生成完成
-              # 等待一下确保文件写入完成
-              sleep(1)
-              return true
-            else
-              puts "\e[31m✗ gradle wrapper生成失败\e[0m"
-              return false
-            end
-          end
-        else
-          puts "\e[31m✗ 未找到gradle可执行文件\e[0m"
+        # 验证解压后的wrapper jar文件
+        unless verify_gradle_wrapper_jar_complete(extracted_wrapper_jar, gradle_version)
+          puts "\e[33m⚠ 解压后的wrapper jar文件验证失败\e[0m"
+          FileUtils.rm_rf(extract_temp_dir)
           return false
         end
         
+        # 复制解压后的wrapper jar文件到目标位置
+        FileUtils.cp(extracted_wrapper_jar, wrapper_jar_path)
+        puts "\e[32m✓ 成功从Gradle分发包提取gradle-wrapper.jar\e[0m"
+        
+        # 清理临时目录
+        FileUtils.rm_rf(extract_temp_dir)
+        
+        return true
+        
       rescue => e
-        puts "\e[31m✗ 下载并生成wrapper异常: #{e.message}\e[0m"
+        puts "\e[31m✗ 从Gradle分发包提取wrapper jar异常: #{e.message}\e[0m"
         false
       ensure
-        # 延迟清理临时目录，确保wrapper生成完成
+        # 清理临时目录
         if temp_dir && File.directory?(temp_dir)
-          puts "清理临时目录: #{temp_dir}"
           FileUtils.rm_rf(temp_dir)
         end
       end
     end
 
-    # 使用curl下载文件（备用方案）
+
+    # 简化的curl下载方法（直接使用简化版本）
     def download_with_curl(url, file_path)
       puts "使用curl下载: #{url}"
       
-      # 使用curl命令下载，支持重定向和SSL
-      curl_cmd = [
-        'curl',
-        '-L',                    # 跟随重定向
-        '-s',                    # 静默模式
-        '--connect-timeout', '30',  # 连接超时
-        '--max-time', '300',     # 最大时间5分钟
-        '--retry', '3',          # 重试3次
-        '--retry-delay', '2',    # 重试延迟2秒
-        '--user-agent', 'Pindo Gradle Wrapper Helper/1.0',
-        '-o', file_path,         # 输出文件
-        url
-      ]
+      # 检查curl是否可用
+      unless system("which curl > /dev/null 2>&1")
+        puts "\e[31m✗ curl命令不可用，请安装curl\e[0m"
+        return false
+      end
+      
+      # 使用简化的curl命令
+      simple_cmd = "curl -L -o '#{file_path}' '#{url}'"
+      puts "执行curl命令: #{simple_cmd}"
       
-      if system(*curl_cmd)
+      if system(simple_cmd)
         if File.exist?(file_path) && File.size(file_path) > 0
           puts "\e[32m✓ curl下载成功: #{File.size(file_path)} 字节\e[0m"
           return true
@@ -498,7 +595,7 @@ module Pindo
           return false
         end
       else
-        puts "\e[31m✗ curl下载失败: 命令执行失败\e[0m"
+        puts "\e[31m✗ curl下载失败\e[0m"
         return false
       end
     rescue => e
@@ -506,62 +603,10 @@ module Pindo
       false
     end
 
-    # 验证gradle-wrapper.jar文件
-    def verify_gradle_wrapper_jar(jar_path, expected_version)
-      # 检查文件是否存在且大小合理
-      File.exist?(jar_path) && File.size(jar_path) > MIN_GRADLE_WRAPPER_JAR_SIZE
-    end
 
 
-    # 从gradle分发包中提取gradle-wrapper.jar
-    def extract_gradle_wrapper_jar(zip_path, target_path)
-      puts "正在从gradle分发包中提取gradle-wrapper.jar..."
-      puts "ZIP文件: #{zip_path}"
-      puts "ZIP文件大小: #{File.size(zip_path)} 字节"
-      
-      Zip::File.open(zip_path) do |zip_file|
-        puts "ZIP文件包含 #{zip_file.count} 个文件"
-        
-        # 列出ZIP文件中的所有文件（用于调试）
-        puts "ZIP文件内容:"
-        zip_file.each_with_index do |entry, index|
-          puts "  #{index + 1}. #{entry.name}"
-          break if index >= 10  # 只显示前10个文件
-        end
-        puts "  ..." if zip_file.count > 10
-        
-        # 查找gradle-wrapper.jar
-        wrapper_entry = zip_file.find { |entry| entry.name.include?('gradle-wrapper.jar') }
-        
-        if wrapper_entry
-          puts "找到gradle-wrapper.jar: #{wrapper_entry.name}"
-          wrapper_entry.extract(target_path)
-          puts "\e[32m✓ gradle-wrapper.jar提取成功\e[0m"
-          return true
-        else
-          puts "\e[31m✗ 在gradle分发包中未找到gradle-wrapper.jar\e[0m"
-          puts "尝试查找其他可能的wrapper文件..."
-          
-          # 查找其他可能的wrapper文件
-          wrapper_entries = zip_file.select { |entry| entry.name.include?('wrapper') }
-          if wrapper_entries.any?
-            puts "找到以下wrapper相关文件:"
-            wrapper_entries.each do |entry|
-              puts "  - #{entry.name}"
-            end
-          else
-            puts "未找到任何wrapper相关文件"
-          end
-          
-          return false
-        end
-      end
-    rescue => e
-      puts "\e[31m✗ 解压gradle-wrapper.jar失败: #{e.message}\e[0m"
-      false
-    end
 
-    # 生成gradlew脚本
+    # 改进的生成gradlew脚本逻辑（优先生成新脚本）
     def generate_gradlew_script(project_path)
       gradlew_path = File.join(project_path, "gradlew")
       
@@ -573,7 +618,7 @@ module Pindo
 
       puts "正在生成gradlew脚本..."
       
-      # 生成gradlew脚本内容（通用脚本，不依赖版本）
+      # 1. 优先生成新的gradlew脚本
       gradlew_content = generate_gradlew_content()
       
       # 写入gradlew文件
@@ -582,8 +627,20 @@ module Pindo
       # 设置执行权限
       system("chmod", "+x", gradlew_path)
       
-      puts "\e[32m✓ gradlew脚本生成完成\e[0m"
-      true
+      # 验证生成的脚本
+      if File.exist?(gradlew_path) && File.executable?(gradlew_path)
+        puts "\e[32m✓ gradlew脚本生成完成\e[0m"
+        return true
+      end
+      
+      # 2. 如果生成失败，回退到内置脚本
+      puts "\e[33m⚠ 生成脚本失败，使用内置 gradlew 脚本\e[0m"
+      if use_builtin_gradlew_script(project_path)
+        return true
+      end
+      
+      puts "\e[31m✗ 无法生成有效的 gradlew 脚本\e[0m"
+      false
     end
 
     # 生成gradlew脚本内容（通用脚本，适用于所有Gradle项目）

data/lib/pindo/module/appselect.rb

@@ -107,6 +107,18 @@ module Pindo
         end
 
         def get_selected_dev_bundleid()
+          # 检查环境变量
+          env_bundleid = ENV['PINDO_BUNDLE_ID']
+          if env_bundleid && !env_bundleid.empty?
+            puts "\n使用环境变量指定的Bundle ID: #{env_bundleid}"
+            puts
+            # 保存到缓存
+            require_relative '../base/pindocontext'
+            context = Pindo::PindoContext.instance
+            context.set_selection(Pindo::PindoContext::SelectionKey::BUNDLE_ID, env_bundleid)
+            return env_bundleid
+          end
+
           # 检查缓存
           require_relative '../base/pindocontext'
           context = Pindo::PindoContext.instance

data/lib/pindo/module/build/buildhelper.rb

@@ -138,6 +138,60 @@ module Pindo
             latest_tag = get_latest_version_tag(project_dir: current_git_root_path)
 
             unless is_tag_at_head?(git_root_dir: current_git_root_path, tag_name: latest_tag)
+              # 检查环境变量
+              env_tag_decision = ENV['PINDO_TAG_DECISION']
+              if env_tag_decision && !env_tag_decision.empty?
+                case env_tag_decision.downcase
+                when 'new', 'new_tag', '1'
+                  puts "\n环境变量指定：新增版本号,打新Tag"
+                  puts
+                  tag_action_parms = []
+                  is_need_add_tag = true
+                  # 保存到缓存
+                  context = PindoContext.instance
+                  decision = {
+                    tag_action_parms: tag_action_parms,
+                    is_need_add_tag: is_need_add_tag,
+                    action: :new_tag,
+                    description: "新增版本号,打新Tag"
+                  }
+                  context.set_selection(PindoContext::SelectionKey::TAG_DECISION, decision)
+                  return is_need_add_tag, tag_action_parms
+                when 'retag', 'recreate', '2'
+                  puts "\n环境变量指定：将上次的Tag删除重新打Tag"
+                  puts
+                  tag_action_parms = ['--retag']
+                  is_need_add_tag = true
+                  # 保存到缓存
+                  context = PindoContext.instance
+                  decision = {
+                    tag_action_parms: tag_action_parms,
+                    is_need_add_tag: is_need_add_tag,
+                    action: :recreate_tag,
+                    description: "将上次的Tag删除重新打Tag"
+                  }
+                  context.set_selection(PindoContext::SelectionKey::TAG_DECISION, decision)
+                  return is_need_add_tag, tag_action_parms
+                when 'skip', 'no', 'none', '3'
+                  puts "\n环境变量指定：不需要Tag继续编译"
+                  puts
+                  tag_action_parms = nil
+                  is_need_add_tag = false
+                  # 保存到缓存
+                  context = PindoContext.instance
+                  decision = {
+                    tag_action_parms: tag_action_parms,
+                    is_need_add_tag: is_need_add_tag,
+                    action: :continue_without_tag,
+                    description: "不需要Tag继续编译且上传"
+                  }
+                  context.set_selection(PindoContext::SelectionKey::TAG_DECISION, decision)
+                  return is_need_add_tag, tag_action_parms
+                when 'exit', 'quit', '4'
+                  raise Informative, "环境变量指定：终止退出编译!"
+                end
+              end
+
               if auto_mode 
                 # 在自动化模式或没有交互式终端时，默认选择新增版本号打新Tag
                 puts "检测到当前代码没有打Tag，在自动模式下将自动新增版本号并打新Tag"