emerge 0.2.2 → 0.4.0

data/lib/utils/macho_parser.rb

@@ -0,0 +1,325 @@
+require 'macho'
+
+module EmergeCLI
+  class MachOParser
+    TYPE_METADATA_KIND_MASK = 0x7 << 3
+    TYPE_METADATA_KIND_SHIFT = 3
+
+    # Bind Codes
+    BIND_OPCODE_MASK = 0xF0
+    BIND_IMMEDIATE_MASK = 0x0F
+    BIND_OPCODE_DONE = 0x00
+    BIND_OPCODE_SET_DYLIB_ORDINAL_IMM = 0x10
+    BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB = 0x20
+    BIND_OPCODE_SET_DYLIB_SPECIAL_IMM = 0x30
+    BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM = 0x40
+    BIND_OPCODE_SET_TYPE_IMM = 0x50
+    BIND_OPCODE_SET_ADDEND_SLEB = 0x60
+    BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x70
+    BIND_OPCODE_ADD_ADDR_ULEB = 0x80
+    BIND_OPCODE_DO_BIND = 0x90
+    BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB = 0xA0
+    BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED = 0xB0
+    BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB = 0xC0
+
+    UINT64_SIZE = 8
+    UINT64_MAX_VALUE = 0xFFFFFFFFFFFFFFFF
+
+    def load_binary(binary_path)
+      @macho_file = MachO::MachOFile.new(binary_path)
+      @binary_data = File.binread(binary_path)
+    end
+
+    def read_linkedit_data_command
+      chained_fixups_command = nil
+      @macho_file.load_commands.each do |lc|
+        chained_fixups_command = lc if lc.type == :LC_DYLD_CHAINED_FIXUPS
+      end
+
+      if chained_fixups_command.nil?
+        Logger.debug 'No LC_DYLD_CHAINED_FIXUPS found'
+        return false, []
+      end
+
+      # linkedit_data_command
+      _, _, dataoff, datasize = @binary_data[chained_fixups_command.offset, 16].unpack('L<L<L<L<')
+
+      header = @binary_data[dataoff, datasize].unpack('L<L<L<L<L<L<L<')
+      # dyld_chained_fixups_header
+      _, _, imports_offset, symbols_offset, imports_count,
+        imports_format, = header
+
+      imports_start = dataoff + imports_offset
+      symbols_start = dataoff + symbols_offset
+
+      imported_symbols = []
+
+      import_size, name_offset_proc =
+        case imports_format
+        when 1, nil # DYLD_CHAINED_IMPORT
+          [4, ->(ptr) { ptr.unpack1('L<') >> 9 }]
+        when 2 # DYLD_CHAINED_IMPORT_ADDEND
+          [8, ->(ptr) { ptr.unpack1('L<') >> 9 }]
+        when 3 # DYLD_CHAINED_IMPORT_ADDEND64
+          [16, ->(ptr) { ptr.unpack1('Q<') >> 32 }]
+        end
+
+      # Extract imported symbol names
+      imports_count.times do |i|
+        import_offset = imports_start + (i * import_size)
+        name_offset = name_offset_proc.call(@binary_data[import_offset, import_size])
+        name_start = symbols_start + name_offset
+        name = read_null_terminated_string(@binary_data[name_start..])
+        imported_symbols << name
+      end
+
+      [true, imported_symbols]
+    end
+
+    def read_dyld_info_only_command
+      dyld_info_only_command = nil
+      @macho_file.load_commands.each do |lc|
+        dyld_info_only_command = lc if lc.type == :LC_DYLD_INFO_ONLY
+      end
+
+      if dyld_info_only_command.nil?
+        Logger.debug 'No LC_DYLD_INFO_ONLY found'
+        return []
+      end
+
+      bound_symbols = []
+      start_address = dyld_info_only_command.bind_off
+      end_address = dyld_info_only_command.bind_off + dyld_info_only_command.bind_size
+      current_address = start_address
+
+      current_symbol = BoundSymbol.new(segment_offset: 0, library: nil, offset: 0, symbol: '')
+      while current_address < end_address
+        results, current_address, current_symbol = read_next_symbol(@binary_data, current_address, end_address,
+                                                                    current_symbol)
+
+        # Dup items to avoid pointer issues
+        results.each do |res|
+          bound_symbols << res.dup
+        end
+      end
+
+      # Filter only swift symbols starting with _$s
+      swift_symbols = bound_symbols.select { |bound_symbol| bound_symbol.symbol.start_with?('_$s') }
+
+      load_commands = @macho_file.load_commands.select { |lc| lc.type == :LC_SEGMENT_64 || lc.type == :LC_SEGMENT } # rubocop:disable Naming/VariableNumber
+
+      swift_symbols.each do |swift_symbol|
+        swift_symbol.address = load_commands[swift_symbol.segment_offset].vmaddr + swift_symbol.offset
+      end
+
+      swift_symbols
+    end
+
+    def find_protocols_in_swift_proto(use_chained_fixups, imported_symbols, bound_symbols, search_symbols)
+      found_section = nil
+      @macho_file.segments.each do |segment|
+        segment.sections.each do |section|
+          if section.segname.strip == '__TEXT' && section.sectname.strip == '__swift5_proto'
+            found_section = section
+            break
+          end
+        end
+      end
+
+      unless found_section
+        Logger.error 'The __swift5_proto section was not found.'
+        return false
+      end
+
+      start = found_section.offset
+      size = found_section.size
+      offsets_list = parse_list(@binary_data, start, size)
+
+      offsets_list.each do |relative_offset, offset_start|
+        type_file_address = offset_start + relative_offset
+        if type_file_address <= 0 || type_file_address >= @binary_data.size
+          Logger.error 'Invalid protocol conformance offset'
+          next
+        end
+
+        # ProtocolConformanceDescriptor -> ProtocolDescriptor
+        protocol_descriptor = read_little_endian_signed_integer(@binary_data, type_file_address)
+
+        # # ProtocolConformanceDescriptor -> ConformanceFlags
+        conformance_flags = read_little_endian_signed_integer(@binary_data, type_file_address + 12)
+        kind = (conformance_flags & TYPE_METADATA_KIND_MASK) >> TYPE_METADATA_KIND_SHIFT
+
+        next unless kind == 0
+
+        indirect_relative_offset = get_indirect_relative_offset(type_file_address, protocol_descriptor)
+
+        bound_symbol = bound_symbols.find { |symbol| symbol.address == indirect_relative_offset }
+        if bound_symbol
+          return true if search_symbols.include?(bound_symbol.symbol)
+        elsif use_chained_fixups
+          descriptor_offset = protocol_descriptor & ~1
+          jump_ptr = type_file_address + descriptor_offset
+
+          address = @binary_data[jump_ptr, 4].unpack1('I<')
+          symbol_name = imported_symbols[address]
+          return true if search_symbols.include?(symbol_name)
+        end
+      end
+      false
+    end
+
+    private
+
+    def read_next_symbol(binary_data, current_address, end_address, current_symbol)
+      while current_address < end_address
+        first_byte = read_byte(binary_data, current_address)
+        current_address += 1
+        immediate = first_byte & BIND_IMMEDIATE_MASK
+        opcode = first_byte & BIND_OPCODE_MASK
+
+        case opcode
+        when BIND_OPCODE_DONE
+          result = current_symbol.dup
+          current_symbol.segment_offset = 0
+          current_symbol.library = 0
+          current_symbol.offset = 0
+          current_symbol.symbol = ''
+          return [result], current_address, current_symbol
+        when BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
+          current_symbol.library = [immediate].pack('L').unpack1('L')
+        when BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
+          current_symbol.symbol = read_null_terminated_string(binary_data[current_address..])
+          # Increase current pointer
+          current_address += current_symbol.symbol.size + 1
+        when BIND_OPCODE_ADD_ADDR_ULEB
+          offset, new_current_address = read_uleb(@binary_data, current_address)
+          current_symbol.offset = (current_symbol.offset + offset) & UINT64_MAX_VALUE
+          current_address = new_current_address
+        when BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB
+          offset, new_current_address = read_uleb(@binary_data, current_address)
+          current_symbol.offset = (current_symbol.offset + offset + UINT64_SIZE) & UINT64_MAX_VALUE
+          current_address = new_current_address
+          return [current_symbol], current_address, current_symbol
+        when BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
+          offset, current_address = read_uleb(@binary_data, current_address)
+          current_symbol.segment_offset = immediate
+          current_symbol.offset = offset
+        when BIND_OPCODE_SET_ADDEND_SLEB
+          _, current_address = read_uleb(@binary_data, current_address)
+        when BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED
+          result = current_symbol.dup
+          current_symbol.offset = (
+            current_symbol.offset + (immediate * UINT64_SIZE) + UINT64_SIZE
+          ) & UINT64_MAX_VALUE
+          return [result], current_address, current_symbol
+        when BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB
+          count, current_address = read_uleb(@binary_data, current_address)
+          skipping, current_address = read_uleb(@binary_data, current_address)
+
+          results = []
+          count.times do
+            results << current_symbol.dup
+            current_symbol.offset = (current_symbol.offset + skipping + UINT64_SIZE) & UINT64_MAX_VALUE
+          end
+
+          return results, current_address, current_symbol
+        when BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB
+          count, current_address = read_uleb(@binary_data, current_address)
+          current_symbol.library = count
+        when BIND_OPCODE_DO_BIND
+          result = current_symbol.dup
+          current_symbol.offset = (current_symbol.offset + UINT64_SIZE) & UINT64_MAX_VALUE
+          return [result], current_address, current_symbol
+        end
+      end
+      [[], current_address, current_symbol]
+    end
+
+    def read_byte(binary_data, address)
+      binary_data[address, 1].unpack1('C')
+    end
+
+    def read_little_endian_signed_integer(binary_data, address)
+      binary_data[address, 4].unpack1('l<')
+    end
+
+    def read_uleb(binary_data, address)
+      next_byte = 0
+      size = 0
+      result = 0
+
+      loop do
+        next_byte = read_byte(binary_data, address)
+        address += 1
+        bytes = next_byte & 0x7F
+        shifted = bytes << (size * 7)
+
+        size += 1
+        result |= shifted
+        break if next_byte.nobits?(0x80)
+      end
+
+      [result, address]
+    end
+
+    def read_null_terminated_string(data)
+      data.unpack1('Z*')
+    end
+
+    def vm_address(file_offset, macho)
+      load_commands = macho.load_commands.select { |lc| lc.type == :LC_SEGMENT_64 || lc.type == :LC_SEGMENT } # rubocop:disable Naming/VariableNumber
+      load_commands.each do |lc|
+        next unless file_offset >= lc.fileoff && file_offset < (lc.fileoff + lc.filesize)
+        unless lc.respond_to?(:sections)
+          Logger.error 'Load command does not support sections function'
+          next
+        end
+
+        lc.sections.each do |section|
+          if file_offset >= section.offset && file_offset < (section.offset) + section.size
+            return section.addr + (file_offset - section.offset)
+          end
+        end
+      end
+      nil
+    end
+
+    def parse_list(bytes, start, size)
+      data_pointer = bytes[start..]
+      file_offset = start
+      pointer_size = 4
+      class_pointers = []
+
+      (size / pointer_size).to_i.times do
+        pointer = data_pointer.unpack1('l<')
+        class_pointers << [pointer, file_offset]
+        data_pointer = data_pointer[pointer_size..]
+        file_offset += pointer_size
+      end
+
+      class_pointers
+    end
+
+    def get_indirect_relative_offset(type_file_address, protocol_descriptor)
+      vm_start = vm_address(type_file_address, @macho_file)
+      return nil if vm_start.nil?
+      if (vm_start + protocol_descriptor).odd?
+        (vm_start + protocol_descriptor) & ~1
+      elsif vm_start + protocol_descriptor > 0
+        vm_start + protocol_descriptor
+      end
+    end
+  end
+
+  class BoundSymbol
+    attr_accessor :segment_offset, :library, :offset, :symbol, :address
+
+    def initialize(segment_offset:, library:, offset:, symbol:)
+      @segment_offset = segment_offset
+      @library = library
+      @offset = offset
+      @symbol = symbol
+      @address = 0
+    end
+  end
+end

data/lib/utils/network.rb

@@ -11,22 +11,22 @@ module EmergeCLI
     RETRY_DELAY = 5
     MAX_RETRIES = 3
 
-    def initialize(api_token:, base_url: EMERGE_API_PROD_URL)
+    def initialize(api_token: nil, base_url: EMERGE_API_PROD_URL)
       @base_url = base_url
       @api_token = api_token
       @internet = Async::HTTP::Internet.new
     end
 
-    def get(path:, headers: {})
-      request(:get, path, nil, headers)
+    def get(path:, headers: {}, max_retries: MAX_RETRIES)
+      request(:get, path, nil, headers, nil, max_retries)
     end
 
-    def post(path:, body:, headers: {})
-      request(:post, path, body, headers)
+    def post(path:, body:, headers: {}, query: nil, max_retries: MAX_RETRIES)
+      request(:post, path, body, headers, query, max_retries)
     end
 
-    def put(path:, body:, headers: {})
-      request(:put, path, body, headers)
+    def put(path:, body:, headers: {}, max_retries: MAX_RETRIES)
+      request(:put, path, body, headers, nil, max_retries)
     end
 
     def close
@@ -35,18 +35,23 @@ module EmergeCLI
 
     private
 
-    def request(method, path, body, custom_headers)
+    def request(method, path, body, custom_headers, query = nil, max_retries = MAX_RETRIES)
       uri = if path.start_with?('http')
               URI.parse(path)
             else
-              URI::HTTPS.build(host: @base_url, path:)
+              query_string = query ? URI.encode_www_form(query) : nil
+              URI::HTTPS.build(
+                host: @base_url,
+                path: path,
+                query: query_string
+              )
             end
       absolute_uri = uri.to_s
 
       headers = {
-        'X-API-Token' => @api_token,
         'User-Agent' => "emerge-cli/#{EmergeCLI::VERSION}"
       }
+      headers['X-API-Token'] = @api_token if @api_token
       headers['Content-Type'] = 'application/json' if method == :post && body.is_a?(Hash)
       headers.merge!(custom_headers)
 
@@ -66,10 +71,10 @@ module EmergeCLI
         response
       rescue StandardError => e
         retries += 1
-        if retries <= MAX_RETRIES
+        if retries <= max_retries
           delay = RETRY_DELAY * retries
           error_message = e.message
-          Logger.warn "Request failed (attempt #{retries}/#{MAX_RETRIES}): #{error_message}"
+          Logger.warn "Request failed (attempt #{retries}/#{max_retries}): #{error_message}"
           Logger.warn "Retrying in #{delay} seconds..."
 
           begin
@@ -82,7 +87,9 @@ module EmergeCLI
           sleep delay
           retry
         else
-          Logger.error "Request failed after #{MAX_RETRIES} attempts: #{absolute_uri} #{e.message}"
+          unless max_retries == 0
+            Logger.error "Request failed after #{max_retries} attempts: #{absolute_uri} #{e.message}"
+          end
           raise e
         end
       end

data/lib/utils/version_check.rb

@@ -0,0 +1,32 @@
+require 'json'
+
+module EmergeCLI
+  module Utils
+    class VersionCheck
+      def initialize(network: EmergeCLI::Network.new)
+        @network = network
+      end
+
+      def check_version
+        Sync do
+          response = @network.get(
+            path: 'https://rubygems.org/api/v1/gems/emerge.json',
+            headers: {}
+          )
+          latest_version = JSON.parse(response.read).fetch('version')
+          current_version = EmergeCLI::VERSION
+
+          if Gem::Version.new(latest_version) > Gem::Version.new(current_version)
+            Logger.warn "A new version of emerge-cli is available (#{latest_version})"
+            Logger.warn "You are currently using version #{current_version}"
+            Logger.warn "To update, run: gem update emerge\n"
+          end
+        end
+      rescue KeyError
+        Logger.error 'Failed to parse version from RubyGems API response'
+      rescue StandardError => e
+        Logger.error "Failed to check for updates: #{e.message}"
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module EmergeCLI
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.4.0'.freeze
 end

metadata

@@ -1,43 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: emerge
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Emerge Tools
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-12-02 00:00:00.000000000 Z
+date: 2024-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: async
+  name: async-http
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.21.1
+        version: 0.86.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.21.1
+        version: 0.86.0
 - !ruby/object:Gem::Dependency
-  name: async-http
+  name: CFPropertyList
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.86.0
+        version: '2.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.86.0
+        version: '2.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.2
 - !ruby/object:Gem::Dependency
   name: chunky_png
   requirement: !ruby/object:Gem::Requirement
@@ -81,19 +87,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.2.1
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: ruby-macho
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: 4.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: 4.1.0
 - !ruby/object:Gem::Dependency
   name: ruby_tree_sitter
   requirement: !ruby/object:Gem::Requirement
@@ -165,6 +171,10 @@ files:
 - lib/commands/config/snapshots/snapshots_ios.rb
 - lib/commands/global_options.rb
 - lib/commands/integrate/fastlane.rb
+- lib/commands/order_files/download_order_files.rb
+- lib/commands/order_files/validate_linkmaps.rb
+- lib/commands/reaper/reaper.rb
+- lib/commands/snapshots/validate_app.rb
 - lib/commands/upload/snapshots/client_libraries/default.rb
 - lib/commands/upload/snapshots/client_libraries/paparazzi.rb
 - lib/commands/upload/snapshots/client_libraries/roborazzi.rb
@@ -172,15 +182,24 @@ files:
 - lib/commands/upload/snapshots/snapshots.rb
 - lib/emerge_cli.rb
 - lib/reaper/ast_parser.rb
+- lib/reaper/code_deleter.rb
 - lib/utils/git.rb
 - lib/utils/git_info_provider.rb
 - lib/utils/git_result.rb
 - lib/utils/github.rb
 - lib/utils/logger.rb
+- lib/utils/macho_parser.rb
 - lib/utils/network.rb
 - lib/utils/profiler.rb
 - lib/utils/project_detector.rb
+- lib/utils/version_check.rb
 - lib/version.rb
+- parsers/libtree-sitter-java-darwin-arm64.dylib
+- parsers/libtree-sitter-java-linux-x86_64.so
+- parsers/libtree-sitter-kotlin-darwin-arm64.dylib
+- parsers/libtree-sitter-kotlin-linux-x86_64.so
+- parsers/libtree-sitter-swift-darwin-arm64.dylib
+- parsers/libtree-sitter-swift-linux-x86_64.so
 homepage: https://github.com/EmergeTools/emerge-cli
 licenses:
 - MIT
@@ -204,7 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: Emerge CLI