pindo 5.10.6 → 5.10.9

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

@@ -0,0 +1,1118 @@
+require 'fileutils'
+require 'json'
+require_relative '../../config/pindoconfig'
+
+module Pindo
+  module KeystoreHelper
+    class << self
+
+      # 从 PindoConfig 统一配置中读取 Android 签名配置
+      # @return [Hash, nil] 签名配置哈希，包含 debug 和 release 配置
+      def get_android_sign_config
+        begin
+          # 使用 PindoConfig 单例获取配置
+          pindo_config = Pindoconfig.instance
+
+          # 从 pindo_user_config_json 中获取 android_sign_config
+          android_sign_config = pindo_config.pindo_user_config_json["android_sign_config"]
+
+          if android_sign_config.nil? || android_sign_config.empty?
+            Funlog.warning("配置中未找到 android_sign_config")
+            return nil
+          end
+
+          # 验证配置结构
+          unless validate_sign_config(android_sign_config)
+            Funlog.error("android_sign_config 配置格式不正确")
+            return nil
+          end
+
+          # 解析文件路径
+          android_sign_config = resolve_keystore_paths(android_sign_config)
+
+          return android_sign_config
+
+        rescue => e
+          Funlog.error("读取签名配置失败: #{e.message}")
+          return nil
+        end
+      end
+
+      # 验证签名配置格式
+      # @param config [Hash] 签名配置
+      # @return [Boolean] 是否有效
+      def validate_sign_config(config)
+        return false unless config.is_a?(Hash)
+
+        # 至少需要有 debug 或 release 配置
+        return false if config["debug"].nil? && config["release"].nil?
+
+        # 验证每个配置的必需字段
+        ["debug", "release"].each do |build_type|
+          next if config[build_type].nil?
+
+          cfg = config[build_type]
+          required_fields = ["storeFile", "storePassword", "keyAlias", "keyPassword"]
+
+          required_fields.each do |field|
+            if cfg[field].nil? || cfg[field].to_s.empty?
+              Funlog.error("#{build_type} 配置缺少必需字段: #{field}")
+              return false
+            end
+          end
+        end
+
+        true
+      end
+
+      # 解析 keystore 文件路径
+      # @param config [Hash] 签名配置
+      # @return [Hash] 解析后的配置
+      def resolve_keystore_paths(config)
+        # 使用 PindoConfig 获取配置目录
+        pindo_config = Pindoconfig.instance
+        pindo_common_config_dir = pindo_config.pindo_common_configdir
+
+        resolved_config = {}
+
+        ["debug", "release"].each do |build_type|
+          next if config[build_type].nil?
+
+          cfg = config[build_type].dup
+          store_file = cfg["storeFile"]
+
+          # 如果是相对路径，则基于 pindo_common_config 目录解析
+          unless store_file.start_with?("/")
+            cfg["storeFile"] = File.join(pindo_common_config_dir, store_file)
+          end
+
+          # 验证文件是否存在
+          unless File.exist?(cfg["storeFile"])
+            Funlog.warning("Keystore 文件不存在: #{cfg["storeFile"]}")
+          end
+
+          resolved_config[build_type] = cfg
+        end
+
+        resolved_config
+      end
+
+      # 从工程的 build.gradle 中读取已有的 keystore 配置
+      # @param project_path [String] 项目路径
+      # @param debug [Boolean] 是否为 debug 构建
+      # @return [Hash, nil] keystore 配置哈希
+      def get_keystore_config_from_project(project_path, debug = false)
+        main_module = Pindo::AndroidProjectHelper.get_main_module(project_path)
+        return nil unless main_module
+
+        gradle_kts_path = File.join(main_module, "build.gradle.kts")
+        gradle_path     = File.join(main_module, "build.gradle")
+
+        if File.exist?(gradle_kts_path)
+          puts "KTS 项目，读取 #{File.basename(gradle_kts_path)} 文件"
+          get_keystore_config_kts(gradle_kts_path, project_path, debug)
+        elsif File.exist?(gradle_path)
+          puts "Groovy 项目，读取 #{File.basename(gradle_path)} 文件"
+          get_keystore_config_groovy(gradle_path, project_path, debug)
+        else
+          puts "未找到 build.gradle 或 build.gradle.kts 文件"
+          nil
+        end
+      end
+
+      # 将签名配置应用到 Android 工程
+      # 新策略：
+      # 1. 从 buildTypes 中找到 debug/release 引用的 signingConfig 名称
+      # 2. 检查该 signingConfig 配置是否存在且完整
+      # 3. 如果不完整，用 Pindo 配置更新该 signingConfig
+      # 4. 不修改 buildTypes 中的引用名称
+      # @param project_dir [String] 项目目录
+      # @param build_type [String] 构建类型 "debug" 或 "release"
+      # @return [Boolean] 是否成功
+      def apply_keystore_config(project_dir, build_type = "debug")
+        raise ArgumentError, "项目目录不能为空" if project_dir.nil?
+        raise ArgumentError, "build_type 必须是 debug 或 release" unless ["debug", "release"].include?(build_type)
+
+        # 查找主模块的 build.gradle
+        main_module = Pindo::AndroidProjectHelper.get_main_module(project_dir)
+        unless main_module
+          Funlog.error("无法找到主模块")
+          return false
+        end
+
+        gradle_file = find_gradle_file(main_module)
+        unless gradle_file
+          Funlog.error("无法找到 build.gradle 文件")
+          return false
+        end
+
+        puts "检查并配置 keystore 签名..."
+
+        # 获取签名配置并拷贝 keystore 文件到项目
+        sign_config = get_android_sign_config
+        if sign_config && sign_config[build_type]
+          # 拷贝文件并更新配置路径
+          copy_keystore_to_project(project_dir, build_type, sign_config[build_type])
+        end
+
+        # 根据文件类型选择处理方法，传递修改后的配置
+        if gradle_file.end_with?(".kts")
+          ensure_keystore_config_kts(gradle_file, project_dir, build_type, sign_config)
+        else
+          ensure_keystore_config_groovy(gradle_file, project_dir, build_type, sign_config)
+        end
+      end
+
+      private
+
+      # =================== Keystore 文件管理 ===================
+
+      # 拷贝 keystore 文件到项目的 signing 目录
+      # @param project_dir [String] 项目根目录
+      # @param build_type [String] 构建类型 "debug" 或 "release"
+      # @param config [Hash] keystore 配置
+      def copy_keystore_to_project(project_dir, build_type, config)
+        return unless config && config["storeFile"]
+
+        source_file = config["storeFile"]
+        return unless File.exist?(source_file)
+
+        # 创建 signing 目录
+        signing_dir = File.join(project_dir, "signing")
+        FileUtils.mkdir_p(signing_dir) unless File.directory?(signing_dir)
+
+        # 生成目标文件名（使用 build_type 作为前缀）
+        source_filename = File.basename(source_file)
+        target_filename = "#{build_type}_#{source_filename}"
+        target_file = File.join(signing_dir, target_filename)
+
+        # 拷贝文件（如果源文件和目标文件不同）
+        unless File.exist?(target_file) && FileUtils.identical?(source_file, target_file)
+          puts "  拷贝 keystore 文件到项目: signing/#{target_filename}"
+          FileUtils.cp(source_file, target_file)
+          # 设置文件权限为只读
+          File.chmod(0444, target_file)
+        end
+
+        # 更新配置中的路径为相对路径（用于后续生成配置）
+        config["relative_store_file"] = "$rootDir/signing/#{target_filename}"
+      end
+
+      # =================== 确保 keystore 配置的核心方法 ===================
+
+      # 确保 Groovy 格式的 build.gradle 有完整的 keystore 配置
+      # 新策略：
+      # 1. 检查 buildTypes 中是否有 signingConfig 引用
+      # 2. 如果有引用，始终更新对应的 signingConfigs 为相对路径
+      # 3. 不再检查配置是否"完整"，直接替换
+      def ensure_keystore_config_groovy(gradle_file, project_dir, build_type, sign_config = nil)
+        content = File.read(gradle_file)
+        original_content = content.dup
+
+        # 使用更宽松的方式提取 signingConfig 引用
+        signing_config_name = extract_signing_config_reference_safely_groovy(content, build_type)
+
+        if signing_config_name
+          # buildTypes 中已有 signingConfig 引用
+          puts "  buildTypes.#{build_type} 引用的签名配置: #{signing_config_name}"
+
+          # 获取 Pindo 配置
+          sign_config ||= get_android_sign_config
+          pindo_config = sign_config ? sign_config[build_type] : nil
+
+          unless pindo_config
+            Funlog.error("无法获取 Pindo 配置")
+            return false
+          end
+
+          # 确保使用相对路径
+          unless pindo_config["relative_store_file"]
+            source_filename = File.basename(pindo_config["storeFile"])
+            pindo_config["relative_store_file"] = "$rootDir/signing/#{build_type}_#{source_filename}"
+          end
+
+          # 始终更新 signingConfigs 为 Pindo 配置（确保使用相对路径）
+          puts "  → 更新 signingConfigs.#{signing_config_name} 为 Pindo 配置"
+          puts "     使用路径: #{pindo_config["relative_store_file"]}"
+
+          # 先删除旧配置，再注入新配置
+          content = inject_signing_config_groovy(content, signing_config_name, pindo_config)
+        else
+          # 没有 signingConfig 引用，跳过
+          puts "  ⚠ buildTypes.#{build_type} 中未找到 signingConfig 引用"
+          puts "  → 跳过配置（避免破坏 buildTypes 结构）"
+        end
+
+        # 写入文件
+        if content != original_content
+          File.write(gradle_file, content)
+          puts "  ✓ build.gradle 已更新"
+        else
+          puts "  ✓ build.gradle 无需修改"
+        end
+
+        true
+      end
+
+      # 确保 Kotlin DSL 格式的 build.gradle.kts 有完整的 keystore 配置
+      # 新策略：
+      # 1. 检查 buildTypes 中是否有 signingConfig 引用
+      # 2. 如果有引用，始终更新对应的 signingConfigs 为相对路径
+      # 3. 不再检查配置是否"完整"，直接替换
+      def ensure_keystore_config_kts(gradle_file, project_dir, build_type, sign_config = nil)
+        content = File.read(gradle_file)
+        original_content = content.dup
+
+        # 使用更宽松的方式提取 signingConfig 引用
+        signing_config_name = extract_signing_config_reference_safely_kts(content, build_type)
+
+        if signing_config_name
+          # buildTypes 中已有 signingConfig 引用
+          puts "  buildTypes.#{build_type} 引用的签名配置: #{signing_config_name}"
+
+          # 获取 Pindo 配置
+          sign_config ||= get_android_sign_config
+          pindo_config = sign_config ? sign_config[build_type] : nil
+
+          unless pindo_config
+            Funlog.error("无法获取 Pindo 配置")
+            return false
+          end
+
+          # 确保使用相对路径
+          unless pindo_config["relative_store_file"]
+            source_filename = File.basename(pindo_config["storeFile"])
+            pindo_config["relative_store_file"] = "$rootDir/signing/#{build_type}_#{source_filename}"
+          end
+
+          # 始终更新 signingConfigs 为 Pindo 配置（确保使用相对路径）
+          puts "  → 更新 signingConfigs.#{signing_config_name} 为 Pindo 配置"
+          puts "     使用路径: #{pindo_config["relative_store_file"]}"
+
+          # 先删除旧配置，再注入新配置
+          content = inject_signing_config_kts(content, signing_config_name, pindo_config)
+        else
+          # 没有 signingConfig 引用，跳过
+          puts "  ⚠ buildTypes.#{build_type} 中未找到 signingConfig 引用"
+          puts "  → 跳过配置（避免破坏 buildTypes 结构）"
+        end
+
+        # 写入文件
+        if content != original_content
+          File.write(gradle_file, content)
+          puts "  ✓ build.gradle.kts 已更新"
+        else
+          puts "  ✓ build.gradle.kts 无需修改"
+        end
+
+        true
+      end
+
+      # 安全地从 buildTypes 中提取 signingConfig 引用（Groovy）
+      # 使用更宽松的正则，支持各种格式
+      def extract_signing_config_reference_safely_groovy(content, build_type)
+        # 提取整个 buildTypes 块
+        build_types_match = content.match(/buildTypes\s*\{[\s\S]*?^\}/m)
+        return nil unless build_types_match
+
+        build_types_block = build_types_match[0]
+
+        # 使用更宽松的正则查找 buildType 块和其中的 signingConfig
+        # 支持格式：
+        # 1. buildTypes { debug {
+        # 2. buildTypes {\n    debug {
+        # 3. buildTypes {release { debug {
+        if build_types_block =~ /#{build_type}\s*\{[^}]*signingConfig\s+signingConfigs\.(\w+)/m
+          return $1
+        end
+
+        nil
+      end
+
+      # 从 buildTypes 中提取 signingConfig 引用（Groovy）- 保留旧函数供其他地方使用
+      def extract_signing_config_reference_from_build_types_groovy(content, build_type)
+        # 提取 buildTypes 块
+        build_types_match = content.match(/buildTypes\s*\{([\s\S]*?)^\s*\}/m)
+        return nil unless build_types_match
+
+        build_types_content = build_types_match[1]
+
+        # 提取指定 buildType 的块
+        build_type_block = extract_build_type_block_from_content_groovy(build_types_content, build_type)
+        return nil unless build_type_block
+
+        # 提取 signingConfig 引用
+        if build_type_block =~ /signingConfig\s+signingConfigs\.(\w+)/
+          return $1
+        end
+
+        nil
+      end
+
+      # 安全地从 buildTypes 中提取 signingConfig 引用（Kotlin DSL）
+      def extract_signing_config_reference_safely_kts(content, build_type)
+        # 提取整个 buildTypes 块
+        build_types_match = content.match(/buildTypes\s*\{[\s\S]*?^\}/m)
+        return nil unless build_types_match
+
+        build_types_block = build_types_match[0]
+
+        # 使用更宽松的正则查找 buildType 块和其中的 signingConfig
+        if build_types_block =~ /getByName\s*\(\s*"#{build_type}"\s*\)\s*\{[^}]*signingConfig\s*=\s*signingConfigs\.getByName\s*\(\s*"(\w+)"\s*\)/m
+          return $1
+        end
+
+        nil
+      end
+
+      # 从 buildTypes 中提取 signingConfig 引用（Kotlin DSL）- 保留旧函数供其他地方使用
+      def extract_signing_config_reference_from_build_types_kts(content, build_type)
+        # 提取 buildTypes 块
+        build_types_match = content.match(/buildTypes\s*\{([\s\S]*?)^\s*\}/m)
+        return nil unless build_types_match
+
+        build_types_content = build_types_match[1]
+
+        # 提取指定 buildType 的块
+        build_type_block = extract_build_type_block_from_content_kts(build_types_content, build_type)
+        return nil unless build_type_block
+
+        # 提取 signingConfig 引用
+        if build_type_block =~ /signingConfig\s*=\s*signingConfigs\.getByName\s*\(\s*"(\w+)"\s*\)/
+          return $1
+        end
+
+        nil
+      end
+
+      # 从内容中提取 buildType 块（Groovy）
+      def extract_build_type_block_from_content_groovy(content, build_type)
+        match = content.match(/^\s*#{build_type}\s*\{/m)
+        return nil unless match
+
+        start_pos = match.begin(0)
+        brace_count = 0
+        in_block = false
+        end_pos = start_pos
+
+        content[start_pos..-1].each_char.with_index(start_pos) do |char, i|
+          if char == '{'
+            brace_count += 1
+            in_block = true
+          elsif char == '}'
+            brace_count -= 1
+            if in_block && brace_count == 0
+              end_pos = i + 1
+              break
+            end
+          end
+        end
+
+        content[start_pos...end_pos]
+      end
+
+      # 从内容中提取 buildType 块（Kotlin DSL）
+      def extract_build_type_block_from_content_kts(content, build_type)
+        match = content.match(/^\s*getByName\s*\(\s*"#{build_type}"\s*\)\s*\{/m)
+        return nil unless match
+
+        start_pos = match.begin(0)
+        brace_count = 0
+        in_block = false
+        end_pos = start_pos
+
+        content[start_pos..-1].each_char.with_index(start_pos) do |char, i|
+          if char == '{'
+            brace_count += 1
+            in_block = true
+          elsif char == '}'
+            brace_count -= 1
+            if in_block && brace_count == 0
+              end_pos = i + 1
+              break
+            end
+          end
+        end
+
+        content[start_pos...end_pos]
+      end
+
+      # 检查 signing config 是否存在且完整（Groovy）
+      # 增强检查：不仅检查字段是否存在，还检查是否使用了相对路径
+      def check_signing_config_groovy(content, config_name)
+        signing_configs_block = extract_signing_configs_groovy(content)
+        return nil unless signing_configs_block
+
+        config_block = extract_config_block_by_name_groovy(signing_configs_block, config_name)
+        return nil unless config_block
+
+        config_block = remove_groovy_comments(config_block)
+
+        # 检查是否包含所有必需字段
+        has_store_file = config_block =~ /storeFile\s+/
+        has_store_password = config_block =~ /storePassword\s+/
+        has_key_alias = config_block =~ /keyAlias\s+/
+        has_key_password = config_block =~ /keyPassword\s+/
+
+        # 检查是否使用了相对路径（rootProject.file 或 signing 目录）
+        uses_relative_path = config_block =~ /storeFile\s+rootProject\.file/ ||
+                           config_block =~ /storeFile\s+file\(["']signing\//
+
+        # 检查是否使用了绝对路径（不推荐）
+        uses_absolute_path = config_block =~ /storeFile\s+file\(["']\/Users\// ||
+                           config_block =~ /storeFile\s+file\(["']\/home\// ||
+                           config_block =~ /storeFile\s+file\(["']C:\\/
+
+        if has_store_file && has_store_password && has_key_alias && has_key_password
+          if uses_absolute_path
+            # 使用了绝对路径，需要更新
+            puts "  ⚠ 检测到使用绝对路径，需要更新为相对路径"
+            nil
+          elsif uses_relative_path
+            # 使用了相对路径，配置正确
+            { exists: true, relative_path: true }
+          else
+            # 可能使用了其他形式的路径，保守处理
+            { exists: true }
+          end
+        else
+          nil
+        end
+      end
+
+      # 检查 signing config 是否存在且完整（Kotlin DSL）
+      # Pindo 策略：简单检查配置是否存在，如果存在就认为有效
+      # 不解析复杂的变量引用，统一用 Pindo 配置替换
+      def check_signing_config_kts(content, config_name)
+        signing_configs_block = extract_signing_configs_kts(content)
+        return nil unless signing_configs_block
+
+        config_block = extract_config_block_by_name_kts(signing_configs_block, config_name)
+        return nil unless config_block
+
+        config_block = remove_kts_comments(config_block)
+
+        # 检查是否包含所有必需字段
+        has_store_file = config_block =~ /storeFile\s*=/
+        has_store_password = config_block =~ /storePassword\s*=/
+        has_key_alias = config_block =~ /keyAlias\s*=/
+        has_key_password = config_block =~ /keyPassword\s*=/
+
+        # 检查是否使用了相对路径（rootProject.file 或 signing 目录）
+        uses_relative_path = config_block =~ /storeFile\s*=\s*rootProject\.file/ ||
+                           config_block =~ /storeFile\s*=\s*file\(["']signing\//
+
+        # 检查是否使用了绝对路径（不推荐）
+        uses_absolute_path = config_block =~ /storeFile\s*=\s*file\(["']\/Users\// ||
+                           config_block =~ /storeFile\s*=\s*file\(["']\/home\// ||
+                           config_block =~ /storeFile\s*=\s*file\(["']C:\\/
+
+        if has_store_file && has_store_password && has_key_alias && has_key_password
+          if uses_absolute_path
+            # 使用了绝对路径，需要更新
+            puts "  ⚠ 检测到使用绝对路径，需要更新为相对路径"
+            nil
+          elsif uses_relative_path
+            # 使用了相对路径，配置正确
+            { exists: true, relative_path: true }
+          else
+            # 可能使用了其他形式的路径，保守处理
+            { exists: true }
+          end
+        else
+          nil
+        end
+      end
+
+      # 注入签名配置（Groovy）
+      def inject_signing_config_groovy(content, config_name, pindo_config)
+        signing_config_block = generate_signing_config_groovy(config_name, pindo_config)
+
+        # 删除已存在的同名配置
+        content = remove_signing_config_by_name_groovy(content, config_name)
+
+        # 插入新配置
+        insert_signing_config_groovy(content, signing_config_block)
+      end
+
+      # 注入签名配置（Kotlin DSL）
+      def inject_signing_config_kts(content, config_name, pindo_config)
+        signing_config_block = generate_signing_config_kts(config_name, pindo_config)
+
+        # 删除已存在的同名配置
+        content = remove_signing_config_by_name_kts(content, config_name)
+
+        # 插入新配置
+        insert_signing_config_kts(content, signing_config_block)
+      end
+
+      # 删除指定名称的签名配置（Groovy）
+      # 只删除 signingConfigs 块中的配置，不影响其他地方
+      def remove_signing_config_by_name_groovy(content, config_name)
+        # 先找到 signingConfigs 块的位置
+        if content =~ /signingConfigs\s*\{/
+          # 找到 signingConfigs 块的开始位置
+          start_match = $~
+          start_pos = start_match.end(0)
+
+          # 找到对应的结束大括号
+          brace_count = 1
+          end_pos = start_pos
+          content[start_pos..-1].each_char.with_index do |char, index|
+            if char == '{'
+              brace_count += 1
+            elsif char == '}'
+              brace_count -= 1
+              if brace_count == 0
+                end_pos = start_pos + index
+                break
+              end
+            end
+          end
+
+          # 提取 signingConfigs 的内容
+          signing_configs_content = content[start_pos...end_pos]
+
+          # 从内容中删除指定的配置块
+          modified_content = remove_config_block_from_content(signing_configs_content, config_name)
+
+          # 重组完整内容
+          content[0...start_pos] + modified_content + content[end_pos..-1]
+        else
+          content
+        end
+      end
+
+      # 辅助方法：从内容中删除指定的配置块
+      def remove_config_block_from_content(content, config_name)
+        lines = content.split("\n")
+        result_lines = []
+        in_target_block = false
+        brace_count = 0
+
+        lines.each do |line|
+          # 检查是否是目标配置的开始
+          if !in_target_block && line =~ /^\s*#{config_name}\s*\{/
+            in_target_block = true
+            brace_count = 1
+            next
+          end
+
+          # 如果在目标块中，计算大括号
+          if in_target_block
+            line.chars.each do |char|
+              brace_count += 1 if char == '{'
+              brace_count -= 1 if char == '}'
+            end
+
+            # 如果大括号平衡了，说明块结束了
+            if brace_count == 0
+              in_target_block = false
+            end
+            next
+          end
+
+          # 不在目标块中，保留这一行
+          result_lines << line
+        end
+
+        result_lines.join("\n")
+      end
+
+      # 删除指定名称的签名配置（Kotlin DSL）
+      # 只删除 signingConfigs 块中的配置，不影响其他地方
+      def remove_signing_config_by_name_kts(content, config_name)
+        # 先找到 signingConfigs 块的位置
+        if content =~ /signingConfigs\s*\{/
+          # 找到 signingConfigs 块的开始位置
+          start_match = $~
+          start_pos = start_match.end(0)
+
+          # 找到对应的结束大括号
+          brace_count = 1
+          end_pos = start_pos
+          content[start_pos..-1].each_char.with_index do |char, index|
+            if char == '{'
+              brace_count += 1
+            elsif char == '}'
+              brace_count -= 1
+              if brace_count == 0
+                end_pos = start_pos + index
+                break
+              end
+            end
+          end
+
+          # 提取 signingConfigs 的内容
+          signing_configs_content = content[start_pos...end_pos]
+
+          # 从内容中删除指定的配置块（Kotlin DSL 使用 create 语法）
+          modified_content = remove_config_block_from_content_kts(signing_configs_content, config_name)
+
+          # 重组完整内容
+          content[0...start_pos] + modified_content + content[end_pos..-1]
+        else
+          content
+        end
+      end
+
+      # 辅助方法：从 Kotlin DSL 内容中删除指定的配置块
+      def remove_config_block_from_content_kts(content, config_name)
+        lines = content.split("\n")
+        result_lines = []
+        in_target_block = false
+        brace_count = 0
+
+        lines.each do |line|
+          # 检查是否是目标配置的开始（Kotlin DSL 格式）
+          if !in_target_block && line =~ /^\s*create\s*\(\s*["']#{config_name}["']\s*\)\s*\{/
+            in_target_block = true
+            brace_count = 1
+            next
+          end
+
+          # 如果在目标块中，计算大括号
+          if in_target_block
+            line.chars.each do |char|
+              brace_count += 1 if char == '{'
+              brace_count -= 1 if char == '}'
+            end
+
+            # 如果大括号平衡了，说明块结束了
+            if brace_count == 0
+              in_target_block = false
+            end
+            next
+          end
+
+          # 不在目标块中，保留这一行
+          result_lines << line
+        end
+
+        result_lines.join("\n")
+      end
+
+      # =================== 从工程读取 keystore 配置的辅助方法 ===================
+
+      # 处理 Kotlin DSL (build.gradle.kts)
+      # Pindo 策略：配置已经被统一为 signingConfigs.debug/release，直接读取即可
+      def get_keystore_config_kts(gradle_kts_path, project_path, debug)
+        content = File.read(gradle_kts_path)
+        puts "读取 #{File.basename(gradle_kts_path)} 文件"
+
+        build_type = debug ? 'debug' : 'release'
+
+        # 直接从统一的 signingConfigs.debug/release 读取
+        signing_configs_block = extract_signing_configs_kts(content)
+        return nil unless signing_configs_block
+
+        config_block = extract_config_block_by_name_kts(signing_configs_block, build_type)
+
+        # 如果找不到对应的配置，尝试使用另一个配置
+        if config_block.nil?
+          alt_build_type = debug ? 'release' : 'debug'
+          puts "  未找到 signingConfigs.#{build_type}，尝试使用 signingConfigs.#{alt_build_type}"
+          config_block = extract_config_block_by_name_kts(signing_configs_block, alt_build_type)
+          return nil unless config_block
+        end
+
+        config_block = remove_kts_comments(config_block)
+
+        # 直接提取字段值（不处理变量引用）
+        # 支持 file() 和 rootProject.file() 两种格式
+        store_file = config_block[/storeFile\s*=\s*(?:rootProject\.)?file\(["']([^"']+)["']\)/, 1]
+        store_password = config_block[/storePassword\s*=\s*["']([^"']+)["']/, 1]
+        key_alias = config_block[/keyAlias\s*=\s*["']([^"']+)["']/, 1]
+        key_password = config_block[/keyPassword\s*=\s*["']([^"']+)["']/, 1]
+
+        # 解析相对路径
+        store_file = fix_store_file_path(store_file, project_path) if store_file
+
+        {
+          store_file: store_file,
+          store_password: store_password,
+          key_alias: key_alias,
+          key_password: key_password
+        }
+      end
+
+      # 处理 Groovy DSL (build.gradle)
+      def get_keystore_config_groovy(gradle_path, project_path, debug)
+        content = File.read(gradle_path)
+        puts "读取 #{File.basename(gradle_path)} 文件"
+
+        build_type = debug ? 'debug' : 'release'
+
+        # 先从 buildTypes 中找到实际引用的 signingConfig 名称
+        signing_config_name = extract_signing_config_name_from_build_type(content, build_type)
+
+        if signing_config_name.nil?
+          # 如果当前 buildType 没有配置，尝试另一个
+          alt_build_type = debug ? 'release' : 'debug'
+          puts "  buildTypes.#{build_type} 未配置 signingConfig，尝试 buildTypes.#{alt_build_type}"
+          signing_config_name = extract_signing_config_name_from_build_type(content, alt_build_type)
+        end
+
+        if signing_config_name.nil?
+          puts "  未找到任何 signingConfig 配置"
+          return nil
+        end
+
+        puts "  找到签名配置: signingConfigs.#{signing_config_name}"
+
+        # 从 signingConfigs 中读取对应名称的配置
+        signing_configs_block = extract_signing_configs_groovy(content)
+        return nil unless signing_configs_block
+
+        config_block = extract_config_block_by_name_groovy(signing_configs_block, signing_config_name)
+
+        if config_block.nil?
+          puts "  未找到 signingConfigs.#{signing_config_name} 的详细配置"
+          return nil
+        end
+
+        config_block = remove_groovy_comments(config_block)
+
+        # 直接提取字段值（不处理变量引用）
+        # 支持 file() 和 rootProject.file() 两种格式
+        store_file = config_block[/storeFile\s+(?:rootProject\.)?file\(["']([^"']+)["']\)/, 1]
+        store_password = config_block[/storePassword\s+["']([^"']+)["']/, 1]
+        key_alias = config_block[/keyAlias\s+["']([^"']+)["']/, 1]
+        key_password = config_block[/keyPassword\s+["']([^"']+)["']/, 1]
+
+        # 解析相对路径
+        store_file = fix_store_file_path(store_file, project_path) if store_file
+
+        {
+          store_file: store_file,
+          store_password: store_password,
+          key_alias: key_alias,
+          key_password: key_password
+        }
+      end
+
+      def extract_signing_configs_kts(content)
+        # 提取 signingConfigs { ... }，使用大括号计数来正确处理嵌套
+        if content =~ /signingConfigs\s*\{/
+          start_match = $~
+          start_pos = start_match.end(0)
+
+          # 计算大括号平衡
+          brace_count = 1
+          end_pos = start_pos
+
+          content[start_pos..-1].each_char.with_index do |char, index|
+            if char == '{'
+              brace_count += 1
+            elsif char == '}'
+              brace_count -= 1
+              if brace_count == 0
+                end_pos = start_pos + index
+                break
+              end
+            end
+          end
+
+          # 返回 signingConfigs 块的内容（不包括外层大括号）
+          return content[start_pos...end_pos] if brace_count == 0
+        end
+
+        nil
+      end
+
+      # 从 buildTypes 中提取引用的 signingConfig 名称
+      def extract_signing_config_name_from_build_type(content, build_type)
+        # 先提取 buildTypes 块
+        if content =~ /buildTypes\s*\{/
+          start_match = $~
+          start_pos = start_match.end(0)
+
+          # 计算大括号平衡来找到 buildTypes 块的结束
+          brace_count = 1
+          end_pos = start_pos
+
+          content[start_pos..-1].each_char.with_index do |char, index|
+            if char == '{'
+              brace_count += 1
+            elsif char == '}'
+              brace_count -= 1
+              if brace_count == 0
+                end_pos = start_pos + index
+                break
+              end
+            end
+          end
+
+          build_types_block = content[start_pos...end_pos] if brace_count == 0
+
+          if build_types_block
+            # 提取特定 buildType 的配置块
+            build_type_block = extract_config_block_by_name_groovy(build_types_block, build_type)
+
+            if build_type_block
+              # 查找 signingConfig signingConfigs.XXX
+              if build_type_block =~ /signingConfig\s+signingConfigs\.(\w+)/
+                return $1
+              end
+            end
+          end
+        end
+
+        nil
+      end
+
+      def extract_signing_configs_groovy(content)
+        # 提取 signingConfigs { ... }，使用大括号计数来正确处理嵌套
+        if content =~ /signingConfigs\s*\{/
+          start_match = $~
+          start_pos = start_match.end(0)
+
+          # 计算大括号平衡
+          brace_count = 1
+          end_pos = start_pos
+
+          content[start_pos..-1].each_char.with_index do |char, index|
+            if char == '{'
+              brace_count += 1
+            elsif char == '}'
+              brace_count -= 1
+              if brace_count == 0
+                end_pos = start_pos + index
+                break
+              end
+            end
+          end
+
+          # 返回 signingConfigs 块的内容（不包括外层大括号）
+          return content[start_pos...end_pos] if brace_count == 0
+        end
+
+        nil
+      end
+
+      # 根据配置名称提取配置块（Kotlin DSL）
+      def extract_config_block_by_name_kts(signing_configs_block, config_name)
+        # 支持 create("xxx") { ... }
+        match = signing_configs_block.match(/create\s*\(\s*["']#{config_name}["']\s*\)\s*\{([\s\S]*?)^\s*\}/m)
+        match ? match[1] : nil
+      end
+
+      # 根据配置名称提取配置块（Groovy）
+      def extract_config_block_by_name_groovy(signing_configs_block, config_name)
+        # 支持 xxx { ... }
+        match = signing_configs_block.match(/#{config_name}\s*\{([\s\S]*?)^\s*\}/m)
+        match ? match[1] : nil
+      end
+
+      def remove_kts_comments(block)
+        # 去除 // 注释
+        block.lines.reject { |line| line.strip.start_with?("//") }.join
+      end
+
+      def remove_groovy_comments(block)
+        # 去除 // 和 /* ... */ 注释
+        block = block.gsub(/\/\*[\s\S]*?\*\//, "")
+        block.lines.reject { |line| line.strip.start_with?("//") }.join
+      end
+
+      def fix_store_file_path(store_file, project_path)
+        return nil if store_file.nil? || store_file.empty?
+
+        # 如果已经是绝对路径，直接返回
+        return store_file if store_file.start_with?('/') && File.exist?(store_file)
+
+        # 处理相对路径（如 signing/xxx.keystore）
+        # 这种路径来自于 rootProject.file("signing/xxx.keystore")
+        if !store_file.start_with?('/')
+          # 相对路径，基于项目根目录解析
+          absolute_path = File.join(project_path, store_file)
+          return absolute_path if File.exist?(absolute_path)
+
+          # 如果文件不存在，尝试其他位置
+          store_file = File.expand_path(store_file, project_path)
+        end
+
+        # 兼容旧格式：$rootDir、${rootDir}、project.rootDir
+        store_file = store_file.gsub(/^\$?\{?rootDir\}?\/?/, project_path + "/")
+        store_file = store_file.gsub(/^project\.rootDir\/?/, project_path + "/")
+
+        store_file
+      end
+
+      # =================== 写入 keystore 配置的辅助方法 ===================
+
+      # 生成签名配置代码块（Groovy）
+      def generate_signing_config_groovy(config_name, pindo_config)
+        # 优先使用相对路径，如果不存在则使用绝对路径
+        store_file = pindo_config["relative_store_file"] || pindo_config["storeFile"]
+        store_password = pindo_config["storePassword"]
+        key_alias = pindo_config["keyAlias"]
+        key_password = pindo_config["keyPassword"]
+
+        # 如果是相对路径（$rootDir），使用不同的语法
+        if store_file && store_file.start_with?("$rootDir")
+          # 使用 rootProject.file() 或直接使用 $rootDir 变量
+          store_file_line = "storeFile file(\"#{store_file.sub('$rootDir/', '')}\")"
+          if store_file.include?("$rootDir/")
+            # 对于 $rootDir/signing/xxx.keystore 格式
+            relative_path = store_file.sub('$rootDir/', '')
+            store_file_line = "storeFile rootProject.file(\"#{relative_path}\")"
+          end
+        else
+          store_file_line = "storeFile file(\"#{store_file}\")"
+        end
+
+        <<~GROOVY
+          #{config_name} {
+                  #{store_file_line}
+                  storePassword "#{store_password}"
+                  keyAlias "#{key_alias}"
+                  keyPassword "#{key_password}"
+              }
+        GROOVY
+      end
+
+      # 生成签名配置代码块（Kotlin DSL）
+      def generate_signing_config_kts(config_name, pindo_config)
+        # 优先使用相对路径，如果不存在则使用绝对路径
+        store_file = pindo_config["relative_store_file"] || pindo_config["storeFile"]
+        store_password = pindo_config["storePassword"]
+        key_alias = pindo_config["keyAlias"]
+        key_password = pindo_config["keyPassword"]
+
+        # 如果是相对路径（$rootDir），使用不同的语法
+        if store_file && store_file.start_with?("$rootDir")
+          # 对于 Kotlin DSL，使用 rootProject.file()
+          if store_file.include?("$rootDir/")
+            relative_path = store_file.sub('$rootDir/', '')
+            store_file_line = "storeFile = rootProject.file(\"#{relative_path}\")"
+          else
+            store_file_line = "storeFile = file(\"#{store_file}\")"
+          end
+        else
+          store_file_line = "storeFile = file(\"#{store_file}\")"
+        end
+
+        <<~KOTLIN
+          create("#{config_name}") {
+                  #{store_file_line}
+                  storePassword = "#{store_password}"
+                  keyAlias = "#{key_alias}"
+                  keyPassword = "#{key_password}"
+              }
+        KOTLIN
+      end
+
+      # 插入签名配置到 signingConfigs 块（Groovy）
+      def insert_signing_config_groovy(content, signing_config_block)
+        # 查找 signingConfigs 块
+        if content =~ /signingConfigs\s*\{/
+          # 在 signingConfigs 块内插入
+          content.sub(/(signingConfigs\s*\{)/) do
+            "#{$1}\n        #{signing_config_block.strip.gsub(/\n/, "\n        ")}\n"
+          end
+        else
+          # 没有 signingConfigs 块，在 android 块内创建
+          android_match = content.match(/(android\s*\{)/m)
+          if android_match
+            insert_pos = content.index(android_match[0]) + android_match[0].length
+            signing_configs_block = "\n    signingConfigs {\n        #{signing_config_block.strip.gsub(/\n/, "\n        ")}\n    }\n"
+            content.insert(insert_pos, signing_configs_block)
+          else
+            content
+          end
+        end
+      end
+
+      # 插入签名配置到 signingConfigs 块（Kotlin DSL）
+      def insert_signing_config_kts(content, signing_config_block)
+        # 查找 signingConfigs 块
+        if content =~ /signingConfigs\s*\{/
+          # 在 signingConfigs 块内插入
+          content.sub(/(signingConfigs\s*\{)/) do
+            "#{$1}\n        #{signing_config_block.strip.gsub(/\n/, "\n        ")}\n"
+          end
+        else
+          # 没有 signingConfigs 块，在 android 块内创建
+          android_match = content.match(/(android\s*\{)/m)
+          if android_match
+            insert_pos = content.index(android_match[0]) + android_match[0].length
+            signing_configs_block = "\n    signingConfigs {\n        #{signing_config_block.strip.gsub(/\n/, "\n        ")}\n    }\n"
+            content.insert(insert_pos, signing_configs_block)
+          else
+            content
+          end
+        end
+      end
+
+      # 在 buildType 中添加 signingConfig 引用（Groovy）
+      def add_signing_config_reference_to_build_type_groovy(content, build_type, config_name)
+        # 第一步：提取 buildTypes 块
+        build_types_match = content.match(/buildTypes\s*\{([\s\S]*?)^\s*\}/m)
+        return content unless build_types_match
+
+        build_types_content = build_types_match[1]
+        build_types_full = build_types_match[0]
+
+        # 第二步：从 buildTypes 块中提取 buildType
+        build_type_block = extract_build_type_block_from_content_groovy(build_types_content, build_type)
+        return content unless build_type_block
+
+        original_block = build_type_block.dup
+
+        # 第三步：在 buildType 块开始后添加 signingConfig 引用
+        new_block = build_type_block.sub(/^(\s*#{build_type}\s*\{\s*)$/m) do
+          "#{$1}\n            signingConfig signingConfigs.#{config_name}\n"
+        end
+
+        # 第四步：替换 buildTypes 块中的内容
+        new_build_types_content = build_types_content.sub(original_block, new_block)
+        new_build_types_full = build_types_full.sub(build_types_content, new_build_types_content)
+
+        # 第五步：替换整个文件中的 buildTypes 块
+        content.sub(build_types_full, new_build_types_full)
+      end
+
+      # 在 buildType 中添加 signingConfig 引用（Kotlin DSL）
+      def add_signing_config_reference_to_build_type_kts(content, build_type, config_name)
+        # 第一步：提取 buildTypes 块
+        build_types_match = content.match(/buildTypes\s*\{([\s\S]*?)^\s*\}/m)
+        return content unless build_types_match
+
+        build_types_content = build_types_match[1]
+        build_types_full = build_types_match[0]
+
+        # 第二步：从 buildTypes 块中提取 buildType
+        build_type_block = extract_build_type_block_from_content_kts(build_types_content, build_type)
+        return content unless build_type_block
+
+        original_block = build_type_block.dup
+
+        # 第三步：在 buildType 块开始后添加 signingConfig 引用
+        new_block = build_type_block.sub(/^(\s*getByName\s*\(\s*"#{build_type}"\s*\)\s*\{\s*)$/m) do
+          "#{$1}\n            signingConfig = signingConfigs.getByName(\"#{config_name}\")\n"
+        end
+
+        # 第四步：替换 buildTypes 块中的内容
+        new_build_types_content = build_types_content.sub(original_block, new_block)
+        new_build_types_full = build_types_full.sub(build_types_content, new_build_types_content)
+
+        # 第五步：替换整个文件中的 buildTypes 块
+        content.sub(build_types_full, new_build_types_full)
+      end
+
+      # 查找 gradle 文件
+      # @param module_dir [String] 模块目录
+      # @return [String, nil] gradle 文件路径
+      def find_gradle_file(module_dir)
+        gradle_kts = File.join(module_dir, "build.gradle.kts")
+        gradle_groovy = File.join(module_dir, "build.gradle")
+
+        return gradle_kts if File.exist?(gradle_kts)
+        return gradle_groovy if File.exist?(gradle_groovy)
+        nil
+      end
+
+    end
+  end
+end