pindo 5.15.3 → 5.15.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 931d648cd4154c3372f8be276a3f8c1ba343c1ee521997a5b2fc593ea5e4cb18
-  data.tar.gz: 8859ad809b6006f3709b315b6eb830eecd670eb77d49c8109a504f82519acd8d
+  metadata.gz: ef2974c733368b841567503a425a32f359fe03154f73809574b2c1b0a1d2201b
+  data.tar.gz: ac37d8ed02529bc1c487696ef1e450965bc42e8914104bc381ca1486123d35da
 SHA512:
-  metadata.gz: cf977c0431a53abcbcc6da091da61ccbbca6dc420c03507977aef574b4cb85f45ff5f628d021ac8ece839d2fd17362527b5f260d6e76b466fa30c95513fb05ae
-  data.tar.gz: 2b91cb9a006234e86bbc5b66040bbc54ebf7a2c75d01acb8fa44524d7811e321de1de882f3ee84b498b19e1686be73b51f46f8df51bfeb5599214e2498fa680d
+  metadata.gz: 23730681434d87847ef4c5f43aee490d74cfcea7dd754fa9f1f59f6018b59df99296ba67ae808a5a7520865ffebac30b952d304495ce1a2222fc3b73b1828e41
+  data.tar.gz: feef72ac4cfcc0671458083fb6de016e1213ca37ef28be5ff820107bca499962e06ac3e26aaef10d470a52f0df52410085b74f4cc74a92aefcd6b1914dc6d5f4

data/lib/pindo/base/funlog.rb

@@ -1,9 +1,27 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
 require "tty-spinner"
 
 module Pindo
  
   class Funlog
 
+      # 确保字符串使用 UTF-8 编码，防止编码错误导致任务中断
+      # @param str [String] 输入字符串
+      # @return [String] UTF-8 编码的字符串
+      def self.ensure_utf8(str)
+        return str if str.nil?
+        return str if str.encoding == Encoding::UTF_8 && str.valid_encoding?
+        
+        # 尝试转换为 UTF-8
+        begin
+          str.encode(Encoding::UTF_8)
+        rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+          # 如果转换失败，尝试使用替换字符
+          str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+        end
+      end
 
       def create_spinner(info_key:nil)
         # spinner = TTY::Spinner.new("[:spinner] :#{info_key}", format: :dots_2, error_mark: "❌", success_mark: "✅")
@@ -21,15 +39,24 @@ module Pindo
 
 
       def fancyinfo_start(*args)
-        message = args.join(" ")
-        spinner_log_handle.update(title:message)
-        spinner_log_handle.auto_spin
+        message = Funlog.ensure_utf8(args.join(" "))
+        
+        # 检查是否在任务上下文中
+        if Funlog.in_task_context?
+          # 并发模式：路由到输出管理器（只写日志文件）
+          Funlog.current_output_sink.log_info(Funlog.current_task_id, message)
+        else
+          # 串行模式：使用 spinner
+          spinner_log_handle.update(title:message)
+          spinner_log_handle.auto_spin
+        end
+        
         @spinner_log
       end
 
 
       def fancyinfo_update(*args)
-         message = args.join(" ")
+         message = Funlog.ensure_utf8(args.join(" "))
 
          # 检查是否在任务上下文中
          if Funlog.in_task_context?
@@ -45,14 +72,14 @@ module Pindo
       end
 
       def fancyinfo_success(*args)
-         message = args.join(" ")
+         message = Funlog.ensure_utf8(args.join(" "))
          spinner_log_handle.update(title:message)
          spinner_log_handle.success
          @spinner_log =nil
       end
 
       def fancyinfo_error(*args)
-         message = args.join(" ")
+         message = Funlog.ensure_utf8(args.join(" "))
          spinner_log_handle.update(title:message)
          spinner_log_handle.error
          @spinner_log =nil
@@ -61,7 +88,7 @@ module Pindo
       # 输出警告信息（使用spinner，黄色警告标记）
       # @param args [Array] 要输出的消息
       def fancyinfo_warning(*args)
-         message = args.join(" ")
+         message = Funlog.ensure_utf8(args.join(" "))
          spinner_log_handle.update(title:message)
          spinner_log_handle.stop("\e[33m⚠\e[0m")
          @spinner_log = nil
@@ -70,7 +97,7 @@ module Pindo
       # 输出静态成功信息（不使用spinner，对应 fancyinfo_success）
       # @param args [Array] 要输出的消息
       def info(*args)
-         message = args.join(" ")
+         message = Funlog.ensure_utf8(args.join(" "))
 
          # 检查是否在任务上下文中
          if Funlog.in_task_context?
@@ -85,7 +112,7 @@ module Pindo
       # 输出静态警告信息（不使用spinner）
       # @param args [Array] 要输出的消息
       def warning(*args)
-         message = args.join(" ")
+         message = Funlog.ensure_utf8(args.join(" "))
 
          # 检查是否在任务上下文中
          if Funlog.in_task_context?
@@ -100,7 +127,7 @@ module Pindo
       # 输出静态错误信息（不使用spinner，对应 fancyinfo_error）
       # @param args [Array] 要输出的消息
       def error(*args)
-         message = args.join(" ")
+         message = Funlog.ensure_utf8(args.join(" "))
 
          # 检查是否在任务上下文中
          if Funlog.in_task_context?

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

@@ -1,6 +1,8 @@
 require 'fileutils'
 require 'tempfile'
 require 'nokogiri'
+require 'shellwords'
+require 'open3'
 require_relative 'android_project_helper'
 require_relative 'java_env_helper'
 require_relative '../../base/funlog'
@@ -49,12 +51,16 @@ module Pindo
     def self.check_aab_compliance(aab_path)
       result = ComplianceResult.new
       
+      # 先输出标题，使用 puts 确保始终在终端可见
+      puts "\n\e[1m-- 检测 AAB 文件的 Google Play 合规性 --\e[0m"
+
       unless File.exist?(aab_path)
+        puts "\e[31m✗ AAB 文件不存在: #{aab_path}\e[0m"
         result.add_issue("AAB 文件不存在: #{aab_path}")
         return result
       end
       
-      Funlog.fancyinfo_start("Google Play 合规检测: #{File.basename(aab_path)}")
+      puts "\e[1m检测的 AAB 文件：#{File.basename(aab_path)}\e[0m"
       
       # 创建临时目录用于解压 AAB
       temp_dir = nil
@@ -68,9 +74,11 @@ module Pindo
           return result
         end
         
-        # 解压 AAB 文件
-        unless system("unzip", "-q", aab_path, "-d", temp_dir)
-          result.add_issue("无法解压 AAB 文件")
+        # 解压 AAB 文件中的必要文件
+        extract_result = extract_required_files_from_aab(aab_path, temp_dir)
+        unless extract_result[:success]
+          puts "\e[31m✗ #{extract_result[:error_message]}\e[0m"
+          result.add_issue(extract_result[:error_message])
           return result
         end
         
@@ -99,6 +107,331 @@ module Pindo
     
     private
     
+    # 获取 UTF-8 环境变量（用于执行命令）
+    # @return [Hash] 环境变量哈希
+    def self.get_utf8_env
+      {
+        'LANG' => 'en_US.UTF-8',
+        'LC_ALL' => 'en_US.UTF-8'
+      }
+    end
+    
+    # 判断错误信息是否表示文件不存在（可以安全忽略）
+    # @param error_text [String] 错误信息
+    # @return [Boolean] 如果错误表示文件不存在，返回 true
+    def self.is_file_not_found_error?(error_text)
+      error_text.include?('filename not matched') || 
+      error_text.include?('cannot find') || 
+      error_text.include?('not found') ||
+      error_text.empty?
+    end
+    
+    # 解压压缩文件（AAB/APK）内部的单个文件
+    # 注意：内部文件路径不会被 File.expand_path 处理，保持原样
+    # @param archive_path [String] 压缩文件路径（AAB 或 APK）
+    # @param internal_file [String] 压缩文件内部的相对路径（如 base/lib/arm64-v8a/libunity.so）
+    # @param dest_dir [String] 解压目标目录
+    # @return [Hash] {success: Boolean, error: String}
+    def self.extract_internal_file(archive_path, internal_file, dest_dir)
+      begin
+        abs_archive_path = File.expand_path(archive_path)
+        abs_dest_dir = File.expand_path(dest_dir)
+        stdout, stderr, status = Open3.capture3(get_utf8_env, 'unzip', '-q', abs_archive_path, internal_file, '-d', abs_dest_dir)
+        
+        if status.success?
+          return { success: true, error: nil }
+        else
+          error_text = [stderr, stdout].compact.join(' ')
+          if is_file_not_found_error?(error_text)
+            # 文件不存在，可以忽略
+            return { success: true, error: nil }
+          else
+            return { success: false, error: error_text }
+          end
+        end
+      rescue => e
+        return { success: false, error: e.message }
+      end
+    end
+    
+    # 获取可能的 lib 目录列表（用于查找 .so 文件）
+    # @param temp_dir [String] 临时目录路径
+    # @return [Array<String>] lib 目录路径数组
+    def self.get_lib_dirs(temp_dir)
+      [
+        "#{temp_dir}/lib", 
+        "#{temp_dir}/libs",
+        "#{temp_dir}/base/lib",  # AAB文件结构
+        "#{temp_dir}/base/libs"  # AAB文件结构
+      ]
+    end
+    
+    # 在临时目录中查找指定的 .so 文件
+    # @param temp_dir [String] 临时目录路径
+    # @param so_filename [String] .so 文件名（如 libunity.so, libil2cpp.so）
+    # @return [Array<String>] 找到的文件路径数组
+    def self.find_so_files(temp_dir, so_filename)
+      so_files = []
+      get_lib_dirs(temp_dir).each do |lib_dir|
+        if Dir.exist?(lib_dir)
+          found_files = Dir.glob("#{lib_dir}/**/#{so_filename}")
+          so_files += found_files
+        end
+      end
+      so_files
+    end
+    
+    # 判断文件是否是合规检测需要的文件
+    # @param filename [String] AAB 文件内部的相对路径
+    # @return [Boolean] 如果是需要的文件，返回 true
+    def self.is_required_file?(filename)
+      filename.start_with?('base/manifest/') ||
+      (filename.start_with?('base/lib/') && filename.end_with?('.so')) ||
+      filename == 'base.apk' ||
+      filename == 'base/assets/bin/Data/boot.config'
+    end
+    
+    # 从 unzip -Z1 输出中提取文件列表
+    # @param output [String] unzip -Z1 的输出
+    # @return [Array<String>] 文件路径数组
+    def self.parse_unzip_z1_output(output)
+      files = []
+      output.lines.each do |line|
+        filename = line.strip
+        next if filename.empty?
+        files << filename if is_required_file?(filename)
+      end
+      files
+    end
+    
+    # 从 unzip -l 输出中提取文件列表
+    # @param output [String] unzip -l 的输出
+    # @return [Array<String>] 文件路径数组
+    def self.parse_unzip_l_output(output)
+      files = []
+      output.lines.each do |line|
+        # unzip -l 输出格式：长度 日期 时间 文件名
+        # 跳过表头和空行
+        next if line.strip.empty? || line.start_with?('Archive:') || 
+                line.start_with?('Length') || line.start_with?('------') ||
+                line.match(/^\s*$/) || line.match(/^\s*\d+\s+files?\s*$/)
+        
+        # 提取文件名：从行尾开始，跳过前面的数字和日期时间字段
+        filename_match = line.match(/^\s*\d+\s+\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}\s+(.+)$/)
+        next unless filename_match
+        
+        filename = filename_match[1].strip
+        files << filename if is_required_file?(filename)
+      end
+      files
+    end
+    
+    # 从压缩文件中列出并提取需要的文件
+    # @param archive_path [String] 压缩文件路径
+    # @param dest_dir [String] 解压目标目录
+    # @return [Hash] {success: Boolean, error_messages: Array<String>}
+    def self.extract_required_files(archive_path, dest_dir)
+      error_messages = []
+      failed = false
+      
+      # 优先使用 unzip -Z1
+      unzip_list_output, _, unzip_list_status = safe_execute_command('unzip', '-Z1', archive_path)
+      if unzip_list_status.success? && unzip_list_output && !unzip_list_output.strip.empty?
+        required_files = parse_unzip_z1_output(unzip_list_output)
+      else
+        # 回退到 unzip -l
+        unzip_list_output, _, unzip_list_status = safe_execute_command('unzip', '-l', archive_path)
+        if unzip_list_status.success? && unzip_list_output
+          required_files = parse_unzip_l_output(unzip_list_output)
+        else
+          return { success: false, error_messages: ["无法列出 #{archive_path} 中的文件"] }
+        end
+      end
+      
+      # 解压文件
+      required_files.each do |file|
+        extract_result = extract_internal_file(archive_path, file, dest_dir)
+        unless extract_result[:success]
+          failed = true
+          error_messages << "解压 #{file} 失败: #{extract_result[:error]}"
+        end
+      end
+      
+      { success: !failed, error_messages: error_messages }
+    end
+    
+    # 解压 AAB 文件中的必要文件
+    # 只解压合规检测需要的文件，避免解压大型 assets 文件导致错误
+    # 合规检测只需要：
+    # 1. base/manifest/ - Target SDK 检测（如果 bundletool 失败）
+    # 2. base/lib/ - ELF 对齐检测（递归解压所有 .so 文件）
+    # 3. base.apk - 需要进一步解压其中的 lib/
+    # 4. base/assets/bin/Data/boot.config - Unity 检测（如果存在）
+    # 注意：不解压 assets 目录下的其他文件（如 bundle 文件），避免解压错误
+    # @param aab_path [String] AAB 文件路径
+    # @param temp_dir [String] 临时目录路径
+    # @return [Hash] {success: Boolean, error_message: String}
+    def self.extract_required_files_from_aab(aab_path, temp_dir)
+      # 解压 AAB 文件中的必要文件
+      extract_result = extract_required_files(aab_path, temp_dir)
+      unzip_error_messages = extract_result[:error_messages]
+      unzip_failed = !extract_result[:success]
+      
+      # 如果 base.apk 存在，需要进一步解压其中的 lib 目录
+      base_apk_path = File.join(temp_dir, "base.apk")
+      if File.exist?(base_apk_path)
+        # 尝试解压整个 lib/* 目录（包括所有子目录和文件）
+        # 这样可以避免逐个文件解压时遇到文件名编码问题
+        base_apk_lib_output, base_apk_lib_error, base_apk_lib_status = safe_execute_command('unzip', '-q', base_apk_path, 'lib/*', '-d', temp_dir)
+        unless base_apk_lib_status.success?
+          # 如果解压 lib/* 失败，尝试只解压 .so 文件
+          # 优先使用 unzip -Z1 列出文件
+          base_apk_list_output, _, base_apk_list_status = safe_execute_command('unzip', '-Z1', base_apk_path)
+          if base_apk_list_status.success? && base_apk_list_output && !base_apk_list_output.strip.empty?
+            lib_files = base_apk_list_output.lines.map(&:strip).select { |f| f.start_with?('lib/') && f.end_with?('.so') }
+          else
+            # 回退到 unzip -l
+            base_apk_list_output, _, base_apk_list_status = safe_execute_command('unzip', '-l', base_apk_path)
+            if base_apk_list_status.success? && base_apk_list_output
+              lib_files = parse_unzip_l_output(base_apk_list_output).select { |f| f.start_with?('lib/') && f.end_with?('.so') }
+            else
+              lib_files = []
+            end
+          end
+          
+          # 尝试逐个解压 .so 文件
+          lib_files.each do |lib_file|
+            extract_result = extract_internal_file(base_apk_path, lib_file, temp_dir)
+            unless extract_result[:success]
+              # 单个文件解压失败，记录警告但不标记为整体失败
+              # 因为 find_shared_libraries 会再次尝试解压
+              unzip_error_messages << "警告: 解压 base.apk 中的 #{lib_file} 失败: #{extract_result[:error]}"
+            end
+          end
+        end
+      end
+      
+      # 返回结果
+      # 只在实际失败时返回 false，警告信息不影响成功状态
+      # 因为 find_shared_libraries 会再次尝试解压 base.apk 中的文件
+      critical_errors = unzip_error_messages.reject { |msg| msg.include?('警告:') }
+      if unzip_failed && critical_errors.any?
+        error_text = critical_errors.join('; ')
+        error_msg = "无法解压 AAB 文件中的必要文件: #{error_text}"
+        return { success: false, error_message: error_msg }
+      else
+        return { success: true, error_message: nil }
+      end
+    end
+    
+    # 安全执行命令并处理路径编码问题
+    # 确保包含非ASCII字符（如中文、韩语）的路径能够正确处理
+    def self.safe_execute_command(*args)
+      begin
+        # 确保所有参数都是字符串，并正确处理编码
+        safe_args = args.map.with_index do |arg, index|
+          if arg.is_a?(String)
+            # 第一个参数通常是命令名（如 'unzip' 或 '/usr/bin/java'）
+            # 绝对路径（以 '/' 开头）不需要展开，已经是完整路径
+            # 相对路径（包含 '/' 或 '.'）需要展开
+            if index == 0
+              # 第一个参数（命令名）：绝对路径保持原样，相对路径展开
+              if arg.start_with?('/')
+                # 绝对路径：只处理编码，不展开
+                arg.dup.force_encoding('UTF-8').scrub('')
+              else
+                # 相对路径或命令名：不展开（让系统在 PATH 中查找）
+                arg.dup.force_encoding('UTF-8').scrub('')
+              end
+            elsif arg.start_with?('/')
+              # 绝对路径参数：只处理编码，不展开
+              arg.dup.force_encoding('UTF-8').scrub('')
+            elsif arg.include?('/') || arg.start_with?('.')
+              # 相对路径参数：使用 File.expand_path 规范化路径
+              normalized_path = File.expand_path(arg)
+              normalized_path.dup.force_encoding('UTF-8').scrub('')
+            else
+              # 其他参数（如选项 '-q', '-d'）：只处理编码
+              arg.dup.force_encoding('UTF-8').scrub('')
+            end
+          else
+            arg.to_s
+          end
+        end
+        
+        # 使用 Open3 执行命令，避免shell解析问题
+        # 设置环境变量确保输出编码正确
+        stdout, stderr, status = Open3.capture3(get_utf8_env, *safe_args)
+        
+        # 确保输出使用UTF-8编码，并清理可能的路径拼接错误
+        if stdout
+          stdout = stdout.force_encoding('UTF-8')
+          stdout = stdout.scrub('?') unless stdout.valid_encoding?
+          
+          # 清理可能的路径拼接错误：移除临时目录路径和AAB文件名的错误拼接
+          # 例如：launcher-debug.aab/private/var/folders/... 应该被清理
+          stdout = stdout.lines.map do |line|
+            # 如果行中包含临时目录路径模式（/private/var/folders 或 /tmp/），
+            # 并且前面有AAB文件名，则移除临时目录部分
+            if line.match(/\.aab\/[\/\w\-]+(?:private\/var\/folders|tmp\/|aab_compliance_check_)/)
+              # 提取AAB文件名后的相对路径部分
+              # 例如：launcher-debug.aab/private/var/.../yoo_pack/... 
+              # 应该只保留 yoo_pack/... 部分
+              if match = line.match(/\.aab\/[\/\w\-]+(?:private\/var\/folders|tmp\/|aab_compliance_check_)[\/\w\-]+(.+)$/)
+                # 保留压缩包内的相对路径
+                line.sub(/^[^:]*\.aab\/[\/\w\-]+(?:private\/var\/folders|tmp\/|aab_compliance_check_)[\/\w\-]+/, '')
+              else
+                line
+              end
+            else
+              line
+            end
+          end.join
+        end
+        
+        [stdout, stderr, status]
+      rescue => e
+        # 如果出错，返回空结果
+        # 创建一个简单的状态对象，模拟 Process::Status
+        failed_status = Object.new
+        def failed_status.success?; false; end
+        ['', e.message, failed_status]
+      end
+    end
+    
+    # 安全执行shell命令（用于需要管道等shell特性的情况）
+    # 使用 Shellwords.escape 转义路径参数
+    def self.safe_execute_shell_command(command_template, **kwargs)
+      begin
+        # 转义所有路径参数
+        escaped_kwargs = kwargs.transform_values do |value|
+          if value.is_a?(String)
+            # 确保字符串使用UTF-8编码
+            safe_value = value.dup.force_encoding('UTF-8').scrub('')
+            Shellwords.escape(safe_value)
+          else
+            Shellwords.escape(value.to_s)
+          end
+        end
+        
+        # 替换模板中的占位符
+        command = command_template % escaped_kwargs
+        
+        # 执行命令
+        output = `#{command} 2>/dev/null`
+        
+        # 确保输出使用UTF-8编码
+        if output
+          output = output.force_encoding('UTF-8')
+          output = output.scrub('?') unless output.valid_encoding?
+        end
+        
+        output || ''
+      rescue => e
+        ''
+      end
+    end
+    
     # 检查工具是否可用
     def self.tool_available?(tool_name)
       case tool_name
@@ -129,8 +462,6 @@ module Pindo
     
     # 检测 AAB 包体积合规性
     def self.check_aab_size_compliance(aab_path, result)
-      Funlog.fancyinfo_update("检测 AAB 包体积...")
-      
       begin
         # 获取 AAB 文件大小
         aab_size = File.size(aab_path)
@@ -141,36 +472,69 @@ module Pindo
         base_limit_bytes = 194615705 # 185MB
         base_limit_mb = 185
         
-        unzip_out = `unzip -v "#{aab_path}"`
-        if unzip_out && !unzip_out.empty?
-          base_lines = unzip_out.lines.select { |l| l.include?(" base/") }
-          base_size = base_lines.map { |l| l.split[2].to_i }.sum
+        # 使用安全的方式执行 unzip 命令，处理路径中的非ASCII字符
+        # 注意：unzip -v 的输出格式为：
+        # Archive:  filename.aab
+        #   Length   Method    Size  Cmpr    Date    Time   CRC-32   Name
+        # ---------  ------  ------- ---- ---------- ----- --------  ----
+        #    1012  Defl:N      403  60% 01-01-1970 08:00 70391f2c  base/manifest/AndroidManifest.xml
+        # 我们需要提取的是压缩包内的压缩大小（Size列，第3列，索引为2），而不是解压后的大小（Length列）
+        unzip_out, _, status = safe_execute_command('unzip', '-v', aab_path)
+        if status.success? && unzip_out && !unzip_out.empty?
+          # 过滤掉头部信息，只处理文件列表行
+          # 跳过 "Archive:" 行和表头行，只处理实际的文件条目
+          file_lines = unzip_out.lines.reject do |line|
+            line.strip.empty? || 
+            line.start_with?('Archive:') || 
+            line.start_with?('Length') || 
+            line.start_with?('------') ||
+            line.match(/^\s*$/)  # 空行
+          end
+          
+          # 只处理包含 " base/" 的行，并提取压缩后文件大小（Size列，第3列，索引为2）
+          # unzip -v 输出格式：Length Method Size Cmpr Date Time CRC-32 Name
+          base_lines = file_lines.select { |l| l.include?(" base/") }
+          base_size = base_lines.map do |line|
+            parts = line.split
+            # 确保有足够的列，并且第3列（Size）是数字（压缩后大小）
+            # 至少需要8列：Length Method Size Cmpr Date Time CRC-32 Name
+            if parts.length >= 8 && parts[2].match(/^\d+$/)
+              parts[2].to_i
+            else
+              0
+            end
+          end.sum
+          
           result.base_size_mb = (base_size.to_f / 1024 / 1024).round(2)
           result.base_percent = aab_size > 0 ? ((base_size.to_f * 100) / aab_size).round(2) : 0
         end
-        
+
         if base_size > base_limit_bytes
           result.size_compliant = false
           result.add_issue("base 文件夹已超出 Google Play 限制（#{base_limit_mb}MB），请优化资源或分包")
-          Funlog.error("base 文件夹超出限制: #{result.base_size_mb}MB (限制 #{base_limit_mb}MB)")
+          # 只在不合规时输出日志
+          puts "\n\e[1m--- AAB 包体积检测 ---\e[0m"
+          puts "\e[31m✗ base 文件夹超出限制: #{result.base_size_mb}MB (限制 #{base_limit_mb}MB)\e[0m"
         else
           result.size_compliant = true
+          # 合规时不输出日志
         end
 
       rescue => e
+        result.size_compliant = false
         result.add_issue("AAB 包体积检测失败: #{e.message}")
+        # 检测失败时输出日志
+        puts "\n\e[1m--- AAB 包体积检测 ---\e[0m"
+        puts "\e[31m✗ AAB 包体积检测失败: #{e.message}\e[0m"
       end
     end
     
     # 检测 Target SDK 版本合规性
     def self.check_target_sdk_compliance(temp_dir, result, aab_path = nil)
-      Funlog.fancyinfo_update("检测 Target SDK 版本...")
-      
       target_sdk = 0
       
       # 方法1: 使用 bundletool dump manifest（首要方法）
       if aab_path && File.exist?(aab_path)
-        # puts "使用 bundletool 解析 AAB 文件: #{File.basename(aab_path)}"
         target_sdk = extract_target_sdk_with_bundletool(aab_path)
       end
       
@@ -186,14 +550,17 @@ module Pindo
 
       if target_sdk >= 35
         result.target_sdk_compliant = true
+        # 合规时不输出日志
       else
         result.target_sdk_compliant = false
+        # 只在不合规时输出日志
+        puts "\n\e[1m--- Target SDK 版本检测 ---\e[0m"
         if target_sdk == 0
           result.add_issue("无法检测到 Target SDK 版本，请检查 AAB 文件结构")
-          Funlog.error("无法检测到 Target SDK 版本")
+          puts "\e[31m✗ 无法检测到 Target SDK 版本\e[0m"
         else
           result.add_issue("Target SDK #{target_sdk} 不符合要求，需要至少 Target SDK 35 (Android 15)")
-          Funlog.warning("Target SDK: #{target_sdk} (需要至少 35)")
+          puts "\e[33m✗ Target SDK: #{target_sdk} (需要至少 35)\e[0m"
         end
       end
     end
@@ -211,21 +578,26 @@ module Pindo
         # 使用 Pindo 自带的 bundletool.jar
         # 确保使用正确的 Java 版本 (Java 11+)
         java_cmd = get_java_command_for_bundletool
-        bundletool_cmd = "#{java_cmd} -jar \"#{bundletool_jar}\" dump manifest --bundle=\"#{aab_path}\" | grep \"targetSdkVersion\""
-        output = `#{bundletool_cmd} 2>/dev/null`
+        
+        # 使用安全的方式执行 bundletool 命令，处理路径中的非ASCII字符
+        # 先执行 bundletool 命令，然后通过管道传递给 grep
+        bundletool_args = [java_cmd, '-jar', bundletool_jar, 'dump', 'manifest', '--bundle', aab_path]
+        bundletool_output, _, bundletool_status = safe_execute_command(*bundletool_args)
+        
+        # 如果命令成功，在输出中查找 targetSdkVersion
+        output = ''
+        if bundletool_status.success? && bundletool_output
+          output = bundletool_output.lines.grep(/targetSdkVersion/).join
+        end
         
         if output && !output.empty?
-          # puts "bundletool 输出: #{output.strip}"
-          
           # 解析输出格式: <uses-sdk android:minSdkVersion="26" android:targetSdkVersion="34"/>
           if output =~ /android:targetSdkVersion="(\d+)"/
             target_sdk = $1.to_i
-            # puts "从 bundletool 中找到 targetSdkVersion: #{target_sdk}"
             return target_sdk
           end
         end
         
-        # puts "bundletool 未找到 targetSdkVersion"
         return 0
       rescue => e
         return 0
@@ -241,21 +613,23 @@ module Pindo
         end
         
         # 使用系统 bundletool 命令
-        bundletool_cmd = "bundletool dump manifest --bundle=\"#{aab_path}\" | grep \"targetSdkVersion\""
-        output = `#{bundletool_cmd} 2>/dev/null`
+        # 使用安全的方式执行 bundletool 命令，处理路径中的非ASCII字符
+        bundletool_output, _, bundletool_status = safe_execute_command('bundletool', 'dump', 'manifest', '--bundle', aab_path)
+        
+        # 如果命令成功，在输出中查找 targetSdkVersion
+        output = ''
+        if bundletool_status.success? && bundletool_output
+          output = bundletool_output.lines.grep(/targetSdkVersion/).join
+        end
         
         if output && !output.empty?
-          # puts "bundletool 输出: #{output.strip}"
-          
           # 解析输出格式: <uses-sdk android:minSdkVersion="26" android:targetSdkVersion="34"/>
           if output =~ /android:targetSdkVersion="(\d+)"/
             target_sdk = $1.to_i
-            # puts "从系统 bundletool 中找到 targetSdkVersion: #{target_sdk}"
             return target_sdk
           end
         end
         
-        # puts "系统 bundletool 未找到 targetSdkVersion"
         return 0
       rescue => e
         return 0
@@ -314,26 +688,22 @@ module Pindo
           # 在二进制 XML 中搜索 targetSdkVersion 后的数字
           # 模式: targetSdkVersion + 一些二进制数据 + 数字
           if content =~ /targetSdkVersion[^\d]*(\d{1,2})/
-            # puts "从二进制 XML 中找到 targetSdkVersion: #{$1}"
             return $1.to_i
           end
           
           # 尝试更宽泛的搜索模式
           if content =~ /targetSdkVersion.*?(\d{1,2})/
-            # puts "从二进制 XML 中找到 targetSdkVersion (宽泛模式): #{$1}"
             return $1.to_i
           end
           
-          # puts "二进制 XML 中未找到 targetSdkVersion"
           return 0
         end
         
         # 尝试使用 aapt 工具解析（适用于文本格式）
         if tool_available?('aapt')
-          aapt_output = `aapt dump badging "#{manifest_path}" 2>/dev/null`
-          if aapt_output && !aapt_output.empty?
+          aapt_output, _, aapt_status = safe_execute_command('aapt', 'dump', 'badging', manifest_path)
+          if aapt_status.success? && aapt_output && !aapt_output.empty?
             if aapt_output =~ /targetSdkVersion:'(\d+)'/
-              # puts "从 aapt 中找到 targetSdkVersion: #{$1}"
               return $1.to_i
             end
           end
@@ -341,10 +711,9 @@ module Pindo
         
         # 尝试使用 aapt2 工具
         if tool_available?('aapt2')
-          aapt2_output = `aapt2 dump badging "#{manifest_path}" 2>/dev/null`
-          if aapt2_output && !aapt2_output.empty?
+          aapt2_output, _, aapt2_status = safe_execute_command('aapt2', 'dump', 'badging', manifest_path)
+          if aapt2_status.success? && aapt2_output && !aapt2_output.empty?
             if aapt2_output =~ /targetSdkVersion:'(\d+)'/
-              # puts "从 aapt2 中找到 targetSdkVersion: #{$1}"
               return $1.to_i
             end
           end
@@ -352,10 +721,9 @@ module Pindo
         
         # 尝试使用 aapt dump xmltree
         if tool_available?('aapt')
-          aapt_xml_output = `aapt dump xmltree "#{manifest_path}" 2>/dev/null`
-          if aapt_xml_output && !aapt_xml_output.empty?
+          aapt_xml_output, _, aapt_xml_status = safe_execute_command('aapt', 'dump', 'xmltree', manifest_path)
+          if aapt_xml_status.success? && aapt_xml_output && !aapt_xml_output.empty?
             if aapt_xml_output =~ /targetSdkVersion.*?(\d+)/
-              # puts "从 aapt xmltree 中找到 targetSdkVersion: #{$1}"
               return $1.to_i
             end
           end
@@ -372,7 +740,6 @@ module Pindo
         if uses_sdk
           target_sdk = uses_sdk['targetSdkVersion']
           if target_sdk
-            # puts "从 XML 中找到 targetSdkVersion: #{target_sdk}"
             return target_sdk.to_i
           end
         end
@@ -381,7 +748,6 @@ module Pindo
         target_sdk_attrs = doc.xpath('//@targetSdkVersion')
         if !target_sdk_attrs.empty?
           target_sdk = target_sdk_attrs.first.value
-          # puts "从 XML 属性中找到 targetSdkVersion: #{target_sdk}"
           return target_sdk.to_i
         end
         
@@ -389,11 +755,9 @@ module Pindo
         all_attrs = doc.xpath('//@*[contains(name(), "targetSdkVersion")]')
         if !all_attrs.empty?
           target_sdk = all_attrs.first.value
-          # puts "从 XML 中找到 targetSdkVersion 属性: #{target_sdk}"
           return target_sdk.to_i
         end
         
-        # puts "未找到 targetSdkVersion，返回默认值 0"
         return 0
         
       rescue => e
@@ -403,14 +767,13 @@ module Pindo
     
     # 检测 ELF 对齐合规性
     def self.check_elf_alignment_compliance(temp_dir, result)
-      Funlog.fancyinfo_update("检测 ELF 对齐 (16KB 页面大小)...")
-      
       # 查找所有 .so 文件
       so_files = find_shared_libraries(temp_dir)
       result.total_libs = so_files.length
       
       if so_files.empty?
         result.elf_alignment_compliant = true
+        # 合规时不输出日志
         return
       end
       
@@ -438,12 +801,16 @@ module Pindo
       
       if critical_unaligned.empty?
         result.elf_alignment_compliant = true
+        # 合规时不输出日志
       else
         result.elf_alignment_compliant = false
+        # 只在不合规时输出日志
+        puts "\n\e[1m--- ELF 对齐检测 ---\e[0m"
         critical_unaligned.each do |lib|
           result.add_issue("#{lib[:architecture]} 架构的共享库 #{File.basename(lib[:file])} 未对齐 (16KB 页面大小要求)")
+          puts "\e[31m✗ #{lib[:architecture]} 架构的共享库 #{File.basename(lib[:file])} 未对齐 (16KB 页面大小要求)\e[0m"
         end
-        Funlog.error("发现 #{critical_unaligned.length} 个关键架构的未对齐共享库")
+        puts "\e[31m✗ 发现 #{critical_unaligned.length} 个关键架构的未对齐共享库\e[0m"
       end
     end
     
@@ -464,7 +831,9 @@ module Pindo
           base_temp_dir = Dir.mktmpdir("base_apk_libs_")
           
           # 解压 base.apk 中的 lib 目录
-          if system("unzip", "-q", base_apk_path, "lib/*", "-d", base_temp_dir)
+          # 使用 safe_execute_command 解压 lib/*，因为这是通配符模式
+          lib_extract_output, _, lib_extract_status = safe_execute_command('unzip', '-q', base_apk_path, 'lib/*', '-d', base_temp_dir)
+          if lib_extract_status.success?
             Dir.glob(File.join(base_temp_dir, "lib", "**", "*.so")).each do |so_file|
               so_files << so_file
             end
@@ -481,8 +850,9 @@ module Pindo
     def self.check_elf_alignment(so_file)
       begin
         # 首先检查文件是否为有效的 ELF 文件
-        file_output = `file "#{so_file}" 2>/dev/null`
-        unless file_output && file_output.include?('ELF')
+        # 使用安全的方式执行 file 命令，处理路径中的非ASCII字符
+        file_output, _, file_status = safe_execute_command('file', so_file)
+        unless file_status.success? && file_output && file_output.include?('ELF')
           return {
             aligned: false,
             alignment: "not_elf",
@@ -499,9 +869,10 @@ module Pindo
           }
         end
         
-        objdump_output = `objdump -p "#{so_file}" 2>/dev/null`
+        # 使用安全的方式执行 objdump 命令，处理路径中的非ASCII字符
+        objdump_output, _, objdump_status = safe_execute_command('objdump', '-p', so_file)
         
-        if objdump_output && !objdump_output.empty?
+        if objdump_status.success? && objdump_output && !objdump_output.empty?
           # 查找 LOAD 段的对齐信息
           load_sections = objdump_output.lines.select { |line| line.include?('LOAD') }
           
@@ -539,8 +910,9 @@ module Pindo
           }
         end
         
-        readelf_output = `readelf -l "#{so_file}" 2>/dev/null`
-        if readelf_output && !readelf_output.empty?
+        # 使用安全的方式执行 readelf 命令，处理路径中的非ASCII字符
+        readelf_output, _, readelf_status = safe_execute_command('readelf', '-l', so_file)
+        if readelf_status.success? && readelf_output && !readelf_output.empty?
           # 查找 LOAD 段的对齐信息
           load_sections = readelf_output.lines.select { |line| line.include?('LOAD') }
           
@@ -600,7 +972,7 @@ module Pindo
     
     # 打印合规检测摘要
     def self.print_compliance_summary(result)
-      Funlog.fancyinfo_update("生成合规检测摘要...")
+      puts "\n\e[1m--- 生成合规检测摘要 ---\e[0m"
       
       # 总体合规状态
       if result.compliant?
@@ -629,39 +1001,47 @@ module Pindo
     
     # 检测 Unity 漏洞合规性
     def self.check_unity_patch_compliance(temp_dir, result)
-      puts "\n\e[1m--- Unity 漏洞检测 ---\e[0m"
-      
       # 检查是否存在 Unity 相关文件
       unity_files = find_unity_files(temp_dir)
       
       if unity_files.empty?
-        puts "\e[36m信息: 未检测到 Unity 相关文件，跳过 Unity 漏洞检测\e[0m"
+        # 没有 Unity 文件，可能是非 Unity 项目，合规
         result.unity_patch_compliant = true
+        # 不输出日志
         return
       end
       
-      puts "检测到 Unity 项目，开始检查漏洞修复..."
+      # 找到了 Unity 文件，需要检查漏洞修复
+      # 检查 libunity.so 文件（不输出日志）
+      libunity_result = check_libunity_patch(temp_dir, verbose: false)
       
-      # 检查 libunity.so 文件
-      libunity_result = check_libunity_patch(temp_dir)
+      # 检查 boot.config 文件（不输出日志）
+      boot_config_result = check_boot_config_patch(temp_dir, verbose: false)
       
-      # 检查 boot.config 文件
-      boot_config_result = check_boot_config_patch(temp_dir)
-      
-      # 综合判断
+      # 综合判断：libunity.so 和 boot.config 都必须通过检查
       if libunity_result && boot_config_result
         result.unity_patch_compliant = true
         result.unity_xrsdk_patched = true
         result.unity_override_patched = true
-        puts "\e[32m✓ Unity 漏洞检测: 通过\e[0m"
+        # 合规时不输出日志
       else
         result.unity_patch_compliant = false
+        # 只在不合规时输出详细日志
+        puts "\n\e[1m--- Unity 漏洞检测 ---\e[0m"
+        puts "检测到 Unity 项目，开始检查漏洞修复..."
+        
         if !libunity_result
           result.add_issue("Unity libunity.so 漏洞未修复")
+          # 重新检查并输出详细日志
+          check_libunity_patch(temp_dir, verbose: true)
         end
+        
         if !boot_config_result
           result.add_issue("Unity boot.config 漏洞未修复")
+          # 重新检查并输出详细日志
+          check_boot_config_patch(temp_dir, verbose: true)
         end
+        
         puts "\e[31m✗ Unity 漏洞检测: 未通过\e[0m"
       end
     end
@@ -671,18 +1051,7 @@ module Pindo
       unity_files = []
       
       # 查找 libunity.so 文件
-      lib_dirs = [
-        "#{temp_dir}/lib", 
-        "#{temp_dir}/libs",
-        "#{temp_dir}/base/lib",  # AAB文件结构
-        "#{temp_dir}/base/libs"  # AAB文件结构
-      ]
-      lib_dirs.each do |lib_dir|
-        if Dir.exist?(lib_dir)
-          found_so_files = Dir.glob("#{lib_dir}/**/libunity.so")
-          unity_files += found_so_files
-        end
-      end
+      unity_files += find_so_files(temp_dir, 'libunity.so')
       
       # 查找 boot.config 文件
       boot_config_paths = [
@@ -704,110 +1073,107 @@ module Pindo
     # 检查是否使用 il2cpp
     def self.uses_il2cpp?(temp_dir)
       # 检查是否存在 libil2cpp.so 文件
-      lib_dirs = [
-        "#{temp_dir}/lib", 
-        "#{temp_dir}/libs",
-        "#{temp_dir}/base/lib",  # AAB文件结构
-        "#{temp_dir}/base/libs"  # AAB文件结构
-      ]
-      
-      lib_dirs.each do |lib_dir|
-        if Dir.exist?(lib_dir)
-          il2cpp_files = Dir.glob("#{lib_dir}/**/libil2cpp.so")
-          return true if il2cpp_files.any?
-        end
-      end
-      
-      false
+      il2cpp_files = find_so_files(temp_dir, 'libil2cpp.so')
+      il2cpp_files.any?
     end
 
     # 检查 libunity.so 漏洞修复
-    def self.check_libunity_patch(temp_dir)
-      lib_dirs = [
-        "#{temp_dir}/lib", 
-        "#{temp_dir}/libs",
-        "#{temp_dir}/base/lib",  # AAB文件结构
-        "#{temp_dir}/base/libs"  # AAB文件结构
-      ]
-      xrsdk_changed = false
-      override_disabled = false
+    # @param temp_dir [String] 临时目录路径
+    # @param verbose [Boolean] 是否输出详细日志，默认为 true
+    # @return [Boolean] 是否通过检测
+    def self.check_libunity_patch(temp_dir, verbose: true)
+      # 收集所有 libunity.so 文件
+      libunity_files = find_so_files(temp_dir, 'libunity.so')
+      
+      # 如果没有找到 libunity.so 文件，返回 true（不是 Unity 项目或不需要检查）
+      if libunity_files.empty?
+        return true
+      end
+      
+      # 必须所有 libunity.so 文件都通过检查
+      xrsdk_all_passed = true
+      override_all_disabled = true
       override_found = false
       uses_il2cpp = uses_il2cpp?(temp_dir)
       
-      lib_dirs.each do |lib_dir|
-        next unless Dir.exist?(lib_dir)
+      libunity_files.each do |so_file|
+        puts "检查文件: #{File.basename(so_file)}" if verbose
         
-        libunity_files = Dir.glob("#{lib_dir}/**/libunity.so")
+        # 检查 xrsdk 字符串修改
+        xrsdk_passed = check_xrsdk_patch(so_file, verbose: verbose)
+        if xrsdk_passed
+          puts "  \e[32m✓ xrsdk-pre-init-library 字符串已正确修改\e[0m" if verbose
+        else
+          puts "  \e[31m✗ xrsdk-pre-init-library 字符串未正确修改\e[0m" if verbose
+          xrsdk_all_passed = false
+        end
         
-        libunity_files.each do |so_file|
-          puts "检查文件: #{File.basename(so_file)}"
-          
-          # 检查 xrsdk 字符串修改
-          if check_xrsdk_patch(so_file)
-            xrsdk_changed = true
-            puts "  \e[32m✓ xrsdk-pre-init-library 字符串已正确修改\e[0m"
-          else
-            puts "  \e[31m✗ xrsdk-pre-init-library 字符串未正确修改\e[0m"
-          end
-          
-          # 检查 overrideMonoSearchPath 禁用（仅在使用 Mono 时检查）
-          if uses_il2cpp
-            puts "  \e[36m信息: 使用 IL2CPP，跳过 overrideMonoSearchPath 检测\e[0m"
-            override_disabled = true  # IL2CPP 不需要检查 overrideMonoSearchPath
-          else
-            override_result = check_override_patch(so_file)
-            if override_result[:found]
-              override_found = true
-              if override_result[:disabled]
-                override_disabled = true
-                puts "  \e[32m✓ overrideMonoSearchPath 已正确禁用\e[0m"
-              else
-                puts "  \e[31m✗ overrideMonoSearchPath 未正确禁用\e[0m"
-              end
+        # 检查 overrideMonoSearchPath 禁用（仅在使用 Mono 时检查）
+        if uses_il2cpp
+          puts "  \e[36m信息: 使用 IL2CPP，跳过 overrideMonoSearchPath 检测\e[0m" if verbose
+          # IL2CPP 不需要检查 overrideMonoSearchPath
+        else
+          override_result = check_override_patch(so_file, verbose: verbose)
+          if override_result[:found]
+            override_found = true
+            if override_result[:disabled]
+              puts "  \e[32m✓ overrideMonoSearchPath 已正确禁用\e[0m" if verbose
             else
-              puts "  \e[36m信息: 未找到 overrideMonoSearchPath 字符串\e[0m"
+              puts "  \e[31m✗ overrideMonoSearchPath 未正确禁用\e[0m" if verbose
+              override_all_disabled = false
             end
+          else
+            puts "  \e[36m信息: 未找到 overrideMonoSearchPath 字符串\e[0m" if verbose
           end
         end
       end
       
-      # 如果没有找到 overrideMonoSearchPath 或使用 IL2CPP，认为是正常的
+      # 如果没有找到 overrideMonoSearchPath 或使用 IL2CPP，认为 override 检查通过
       if !override_found || uses_il2cpp
-        override_disabled = true
+        override_all_disabled = true
       end
       
-      xrsdk_changed && override_disabled
+      # 所有 libunity.so 文件都必须通过 xrsdk 检查，并且 override 检查也必须通过
+      xrsdk_all_passed && override_all_disabled
     end
     
     # 检查 xrsdk 字符串修补
-    def self.check_xrsdk_patch(so_file)
+    # @param so_file [String] .so 文件路径
+    # @param verbose [Boolean] 是否输出详细日志，默认为 true
+    # @return [Boolean] 是否通过检测
+    def self.check_xrsdk_patch(so_file, verbose: true)
       # 检查是否还存在原始的 xrsdk 字符串
       has_original = false
       has_modified = false
       
       begin
-        # 使用 strings 命令检查文件内容
-        strings_output = `strings "#{so_file}" 2>/dev/null`
+        # 使用安全的方式执行 strings 命令，处理路径中的非ASCII字符
+        strings_output, _, strings_status = safe_execute_command('strings', so_file)
         
-        if strings_output.include?("xrsdk-pre-init-library")
-          has_original = true
-        end
-        
-        if strings_output.include?("8rsdk-pre-init-library")
-          has_modified = true
+        if strings_status.success? && strings_output
+          if strings_output.include?("xrsdk-pre-init-library")
+            has_original = true
+          end
+          
+          if strings_output.include?("8rsdk-pre-init-library")
+            has_modified = true
+          end
         end
         
         # 如果存在修改后的字符串且不存在原始字符串，说明修补成功
         has_modified && !has_original
         
       rescue => e
-        puts "  \e[33m警告: 检查 #{so_file} 时出错: #{e.message}\e[0m"
+        puts "  \e[33m警告: 检查 #{so_file} 时出错: #{e.message}\e[0m" if verbose
         false
       end
     end
     
     # 检查 overrideMonoSearchPath 禁用
-    def self.check_override_patch(so_file)
+    # @param so_file [String] .so 文件路径
+    # @param verbose [Boolean] 是否输出详细日志，默认为 true
+    # @return [Hash] 检测结果 {found: Boolean, disabled: Boolean}
+    def self.check_override_patch(so_file, verbose: true)
       result = { found: false, disabled: false }
       
       begin
@@ -831,14 +1197,17 @@ module Pindo
         end
         
       rescue => e
-        puts "  \e[33m警告: 检查 #{so_file} 时出错: #{e.message}\e[0m"
+        puts "  \e[33m警告: 检查 #{so_file} 时出错: #{e.message}\e[0m" if verbose
       end
       
       result
     end
     
     # 检查 boot.config 漏洞修复
-    def self.check_boot_config_patch(temp_dir)
+    # @param temp_dir [String] 临时目录路径
+    # @param verbose [Boolean] 是否输出详细日志，默认为 true
+    # @return [Boolean] 是否通过检测
+    def self.check_boot_config_patch(temp_dir, verbose: true)
       # 尝试多个可能的boot.config路径
       boot_config_paths = [
         "#{temp_dir}/assets/bin/Data/boot.config",      # 标准APK路径
@@ -855,11 +1224,14 @@ module Pindo
       end
       
       unless boot_config_path
-        puts "  \e[33m信息: 未找到 boot.config 文件\e[0m"
-        return true  # 没有 boot.config 文件，认为是正常的
+        # 如果没有找到 boot.config 文件，检查是否是 Unity 项目
+        # 如果找到了 libunity.so，说明是 Unity 项目，但 boot.config 不存在，这可能是正常的（某些 Unity 版本可能没有）
+        # 如果没找到 libunity.so，说明不是 Unity 项目，返回 true 是合理的
+        puts "  \e[33m信息: 未找到 boot.config 文件\e[0m" if verbose
+        return true  # 没有 boot.config 文件，认为是正常的（可能不是 Unity 项目或不需要修补）
       end
       
-      puts "检查文件: #{File.basename(boot_config_path)}"
+      puts "检查文件: #{File.basename(boot_config_path)}" if verbose
       
       begin
         content = File.read(boot_config_path)
@@ -869,39 +1241,39 @@ module Pindo
         modified_count = content.scan(/8rsdk-pre-init-library/).length
         
         if original_count > 0
-          puts "  \e[31m✗ boot.config 中仍存在 #{original_count} 个未修改的 xrsdk-pre-init-library\e[0m"
+          puts "  \e[31m✗ boot.config 中仍存在 #{original_count} 个未修改的 xrsdk-pre-init-library\e[0m" if verbose
         end
         
         if modified_count > 0
-          puts "  \e[32m✓ boot.config 中发现 #{modified_count} 个修改后的 8rsdk-pre-init-library\e[0m"
+          puts "  \e[32m✓ boot.config 中发现 #{modified_count} 个修改后的 8rsdk-pre-init-library\e[0m" if verbose
         end
         
         # 检查是否还有其他 xrsdk 相关字符串
         other_xrsdk_count = content.scan(/xrsdk/).length
         if other_xrsdk_count > 0
-          puts "  \e[36m信息: boot.config 中发现 #{other_xrsdk_count} 个其他 xrsdk 相关字符串\e[0m"
+          puts "  \e[36m信息: boot.config 中发现 #{other_xrsdk_count} 个其他 xrsdk 相关字符串\e[0m" if verbose
         end
         
         # 如果没有 xrsdk 相关字符串，认为是正常的
         if other_xrsdk_count == 0
-          puts "  \e[32m✓ boot.config 检查结果: 通过（未使用 XR SDK，无需修补）\e[0m"
+          puts "  \e[32m✓ boot.config 检查结果: 通过（未使用 XR SDK，无需修补）\e[0m" if verbose
           return true
         end
         
         # 如果存在修改后的字符串且不存在未修改的字符串，说明修补成功
         if modified_count > 0 && original_count == 0
-          puts "  \e[32m✓ boot.config 检查结果: 通过（已正确替换 #{modified_count} 个字符串）\e[0m"
+          puts "  \e[32m✓ boot.config 检查结果: 通过（已正确替换 #{modified_count} 个字符串）\e[0m" if verbose
           return true
         elsif original_count > 0
-          puts "  \e[31m✗ boot.config 检查结果: 未通过（存在未修改的字符串）\e[0m"
+          puts "  \e[31m✗ boot.config 检查结果: 未通过（存在未修改的字符串）\e[0m" if verbose
           return false
         else
-          puts "  \e[31m✗ boot.config 检查结果: 未通过（未找到修改后的字符串）\e[0m"
+          puts "  \e[31m✗ boot.config 检查结果: 未通过（未找到修改后的字符串）\e[0m" if verbose
           return false
         end
         
       rescue => e
-        puts "  \e[33m警告: 检查 boot.config 时出错: #{e.message}\e[0m"
+        puts "  \e[33m警告: 检查 boot.config 时出错: #{e.message}\e[0m" if verbose
         false
       end
     end

data/lib/pindo/module/task/output/multi_line_output_manager.rb

@@ -65,10 +65,10 @@ module Pindo
           )
           @task_displays[task_id] = display
 
-          # 创建日志文件
+          # 创建日志文件（明确指定 UTF-8 编码，防止中文写入错误）
           log_file_name = "#{task.task_key}_#{task_id}.log"
           log_file_path = File.join(@log_dir, log_file_name)
-          @task_loggers[task_id] = File.open(log_file_path, 'w')
+          @task_loggers[task_id] = File.open(log_file_path, 'w:utf-8')
 
           # 渲染终端
           render_terminal
@@ -356,11 +356,29 @@ module Pindo
         logger = @task_loggers[task_id]
         return unless logger
 
+        # 确保消息使用 UTF-8 编码，防止编码错误导致写入失败
+        safe_message = ensure_utf8(message)
         timestamp = Time.now.strftime('%H:%M:%S')
-        logger.puts("[#{timestamp}] #{message}")
+        logger.puts("[#{timestamp}] #{safe_message}")
         logger.flush
       end
 
+      # 确保字符串使用 UTF-8 编码
+      # @param str [String] 输入字符串
+      # @return [String] UTF-8 编码的字符串
+      def ensure_utf8(str)
+        return str if str.nil?
+        return str if str.encoding == Encoding::UTF_8 && str.valid_encoding?
+        
+        # 尝试转换为 UTF-8
+        begin
+          str.encode(Encoding::UTF_8)
+        rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+          # 如果转换失败，尝试使用替换字符
+          str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+        end
+      end
+
       # 关闭日志文件
       # @param task_id [String] 任务 ID
       def close_log(task_id)
@@ -370,6 +388,15 @@ module Pindo
         logger.close
         @task_loggers.delete(task_id)
       end
+
+      # 关闭所有日志文件（用于清理资源）
+      def close_all_logs
+        @mutex.synchronize do
+          @task_loggers.each_key do |task_id|
+            close_log(task_id)
+          end
+        end
+      end
     end
   end
 end

data/lib/pindo/module/task/output/stdout_redirector.rb

@@ -45,23 +45,41 @@ module Pindo
       def write(message)
         # 捕获输出，写入日志文件（跳过空行）
         unless message.strip.empty?
+          # 确保消息使用 UTF-8 编码，防止编码错误导致任务中断
+          safe_message = ensure_utf8(message.chomp)
           # 根据流类型选择日志级别
           if @stream_type == :stderr
-            @output_manager.log_error(@task_id, message.chomp)
+            @output_manager.log_error(@task_id, safe_message)
           else
-            @output_manager.log_detail(@task_id, message.chomp)
+            @output_manager.log_detail(@task_id, safe_message)
           end
         end
         message.length
       end
 
+      # 确保字符串使用 UTF-8 编码
+      # @param str [String] 输入字符串
+      # @return [String] UTF-8 编码的字符串
+      def ensure_utf8(str)
+        return str if str.nil?
+        return str if str.encoding == Encoding::UTF_8 && str.valid_encoding?
+        
+        # 尝试转换为 UTF-8
+        begin
+          str.encode(Encoding::UTF_8)
+        rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+          # 如果转换失败，尝试使用替换字符
+          str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+        end
+      end
+
       # puts 方法
       # @param args [Array] 参数列表
       def puts(*args)
         if args.empty?
           write("\n")
         else
-          args.each { |arg| write("#{arg}\n") }
+          args.each { |arg| write("#{ensure_utf8(arg.to_s)}\n") }
         end
         nil
       end
@@ -69,7 +87,7 @@ module Pindo
       # print 方法
       # @param args [Array] 参数列表
       def print(*args)
-        write(args.join)
+        write(ensure_utf8(args.join))
         nil
       end
 

data/lib/pindo/module/task/task_manager.rb

@@ -40,6 +40,9 @@ module Pindo
       # 启用输出管理系统
       # @param options [Hash] 配置选项
       def enable_output_management(options = {})
+        # 如果已经有一个输出管理器，先关闭所有日志文件（避免文件句柄泄漏）
+        @output_manager.close_all_logs if @output_manager
+        
         @output_manager = MultiLineOutputManager.new(
           log_dir: options[:log_dir] || './pindo_logs',
           max_lines_per_task: options[:max_lines_per_task] || 5,
@@ -90,6 +93,15 @@ module Pindo
         mode = parse_execution_mode(options)
         strategy = ExecutionStrategy.create(mode, options)
 
+        # 并发模式必须启用输出管理器，否则多线程输出会混乱
+        if mode == :concurrent && @output_manager.nil?
+          enable_output_management(
+            log_dir: options[:log_dir] || './pindo_logs',
+            max_lines_per_task: options[:max_lines_per_task] || 5,
+            max_recent_completed: options[:max_recent_completed] || 3
+          )
+        end
+
         # 如果配置了输出管理器，注册所有任务
         if @output_manager
           @queue.pending_snapshot.each do |task|

data/lib/pindo/version.rb

@@ -6,13 +6,13 @@ require 'time'
 
 module Pindo
 
-  VERSION = "5.15.3"
+  VERSION = "5.15.9"
 
   class VersionCheck
     RUBYGEMS_API = 'https://rubygems.org/api/v1/gems/pindo.json'
     VERSION_INFO_FILE = File.expand_path('~/.pindo/version_info.yml')
     CHECK_INTERVAL = 5 * 60 * 60   # 5小时检查一次
-    CONFIG_MIN_VERSION = '1.3.0'  # 硬编码的配置版本要求
+    CONFIG_MIN_VERSION = '1.4.0'  # 硬编码的配置版本要求
 
     class << self
       # 主版本检查方法（保持向后兼容）

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pindo
 version: !ruby/object:Gem::Version
-  version: 5.15.3
+  version: 5.15.9
 platform: ruby
 authors:
 - wade