emerge 0.4.0 → 0.6.0

data/lib/commands/upload/build.rb

@@ -0,0 +1,140 @@
+require 'dry/cli'
+require 'json'
+require 'uri'
+require 'async'
+require 'async/barrier'
+require 'async/semaphore'
+require 'async/http/internet/instance'
+
+module EmergeCLI
+  module Commands
+    module Upload
+      class Build < EmergeCLI::Commands::GlobalOptions
+        desc 'Upload a build to Emerge'
+
+        option :path, type: :string, required: true, desc: 'Path to the build artifact'
+
+        # Optional options
+        option :api_token, type: :string, required: false,
+                           desc: 'API token for authentication, defaults to ENV[EMERGE_API_TOKEN]'
+        option :sha, type: :string, required: false, desc: 'SHA of the commit'
+        option :branch, type: :string, required: false, desc: 'Branch name'
+        option :repo_name, type: :string, required: false, desc: 'Repository name'
+        option :base_sha, type: :string, required: false, desc: 'Base SHA'
+        option :previous_sha, type: :string, required: false, desc: 'Previous SHA'
+        option :pr_number, type: :string, required: false, desc: 'PR number'
+
+        def initialize(network: nil, git_info_provider: nil)
+          @network = network
+          @git_info_provider = git_info_provider
+        end
+
+        def call(**options)
+          @options = options
+          @profiler = EmergeCLI::Profiler.new(enabled: options[:profile])
+          before(options)
+
+          start_time = Time.now
+
+          file_path = options[:path]
+          file_exists = File.exist?(file_path)
+          raise "File not found at path: #{file_path}" unless file_exists
+
+          file_extension = File.extname(file_path)
+          raise "Unsupported file type: #{file_extension}" unless ['.ipa', '.apk', '.aab',
+                                                                   '.zip'].include?(file_extension)
+
+          api_token = @options[:api_token] || ENV.fetch('EMERGE_API_TOKEN', nil)
+          raise 'API token is required and cannot be blank' if api_token.nil? || api_token.strip.empty?
+
+          @network ||= EmergeCLI::Network.new(api_token:)
+          @git_info_provider ||= GitInfoProvider.new
+
+          Sync do
+            upload_url, upload_id = fetch_upload_url
+
+            file_size = File.size(file_path)
+            Logger.info("Uploading file... (#{file_size} bytes)")
+
+            File.open(file_path, 'rb') do |file|
+              headers = {
+                'Content-Type' => 'application/zip',
+                'Content-Length' => file_size.to_s
+              }
+
+              response = @network.put(
+                path: upload_url,
+                body: file.read,
+                headers: headers
+              )
+
+              unless response.status == 200
+                Logger.error("Upload failed with status #{response.status}")
+                Logger.error("Response body: #{response.body}")
+                raise "Uploading file failed with status #{response.status}"
+              end
+            end
+
+            Logger.info('Upload complete successfully!')
+            Logger.info "Time taken: #{(Time.now - start_time).round(2)} seconds"
+            Logger.info("✅ You can view the build analysis at https://emergetools.com/build/#{upload_id}")
+          end
+        end
+
+        private
+
+        def fetch_upload_url
+          git_result = @git_info_provider.fetch_git_info
+          sha = @options[:sha] || git_result.sha
+          branch = @options[:branch] || git_result.branch
+          base_sha = @options[:base_sha] || git_result.base_sha
+          previous_sha = @options[:previous_sha] || git_result.previous_sha
+          pr_number = @options[:pr_number] || git_result.pr_number
+
+          # TODO: Make optional
+          raise 'SHA is required' unless sha
+          raise 'Branch is required' unless branch
+
+          payload = {
+            sha:,
+            branch:,
+            repo_name: @options[:repo_name],
+            # Optional
+            base_sha:,
+            previous_sha:,
+            pr_number: pr_number&.to_s
+          }.compact
+
+          upload_response = @network.post(
+            path: '/upload',
+            body: payload,
+            headers: { 'Content-Type' => 'application/json' }
+          )
+          upload_json = parse_response(upload_response)
+          upload_id = upload_json.fetch('upload_id')
+          upload_url = upload_json.fetch('uploadURL')
+          Logger.debug("Got upload ID: #{upload_id}")
+
+          warning = upload_json['warning']
+          Logger.warn(warning) if warning
+
+          [upload_url, upload_id]
+        end
+
+        def parse_response(response)
+          case response.status
+          when 200
+            JSON.parse(response.read)
+          when 400
+            error_message = JSON.parse(response.read)['errorMessage']
+            raise "Invalid parameters: #{error_message}"
+          when 401, 403
+            raise 'Invalid API token'
+          else
+            raise "Creating upload failed with status #{response.status}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/emerge_cli.rb

@@ -13,10 +13,18 @@ require_relative 'commands/reaper/reaper'
 require_relative 'commands/snapshots/validate_app'
 require_relative 'commands/order_files/download_order_files'
 require_relative 'commands/order_files/validate_linkmaps'
+require_relative 'commands/order_files/validate_xcode_project'
+require_relative 'commands/upload/build'
+require_relative 'commands/build_distribution/validate_app'
+require_relative 'commands/build_distribution/download_and_install'
+require_relative 'commands/autofixes/minify_strings'
+require_relative 'commands/autofixes/strip_binary_symbols'
+require_relative 'commands/autofixes/exported_symbols'
 
 require_relative 'reaper/ast_parser'
 require_relative 'reaper/code_deleter'
 
+require_relative 'utils/environment'
 require_relative 'utils/git_info_provider'
 require_relative 'utils/git_result'
 require_relative 'utils/github'
@@ -27,6 +35,9 @@ require_relative 'utils/profiler'
 require_relative 'utils/project_detector'
 require_relative 'utils/macho_parser'
 require_relative 'utils/version_check'
+require_relative 'utils/xcode_device_manager'
+require_relative 'utils/xcode_simulator'
+require_relative 'utils/xcode_physical_device'
 
 require 'dry/cli'
 
@@ -34,6 +45,7 @@ module EmergeCLI
   extend Dry::CLI::Registry
 
   register 'upload', aliases: ['u'] do |prefix|
+    prefix.register 'build', Commands::Upload::Build
     prefix.register 'snapshots', Commands::Upload::Snapshots
   end
 
@@ -55,6 +67,18 @@ module EmergeCLI
   register 'order-files' do |prefix|
     prefix.register 'download', Commands::DownloadOrderFiles
     prefix.register 'validate-linkmaps', Commands::ValidateLinkmaps
+    prefix.register 'validate-xcode-project', Commands::ValidateXcodeProject
+  end
+
+  register 'build-distribution' do |prefix|
+    prefix.register 'validate-app', Commands::BuildDistribution::ValidateApp
+    prefix.register 'install', Commands::BuildDistribution::DownloadAndInstall
+  end
+
+  register 'autofix' do |prefix|
+    prefix.register 'minify-strings', Commands::Autofixes::MinifyStrings
+    prefix.register 'strip-binary-symbols', Commands::Autofixes::StripBinarySymbols
+    prefix.register 'exported-symbols', Commands::Autofixes::ExportedSymbols
   end
 end
 

data/lib/reaper/ast_parser.rb

@@ -9,19 +9,22 @@ module EmergeCLI
       DECLARATION_NODE_TYPES = {
         'swift' => %i[class_declaration protocol_declaration],
         'kotlin' => %i[class_declaration protocol_declaration interface_declaration object_declaration],
-        'java' => %i[class_declaration protocol_declaration interface_declaration]
+        'java' => %i[class_declaration protocol_declaration interface_declaration],
+        'objc' => %i[class_declaration protocol_declaration class_implementation class_interface]
       }.freeze
 
       IDENTIFIER_NODE_TYPES = {
         'swift' => %i[simple_identifier qualified_name identifier type_identifier],
         'kotlin' => %i[simple_identifier qualified_name identifier type_identifier],
-        'java' => %i[simple_identifier qualified_name identifier type_identifier]
+        'java' => %i[simple_identifier qualified_name identifier type_identifier],
+        'objc' => %i[simple_identifier qualified_name identifier type_identifier]
       }.freeze
 
       COMMENT_AND_IMPORT_NODE_TYPES = {
         'swift' => %i[comment import_declaration],
         'kotlin' => %i[comment import_header],
-        'java' => %i[comment import_declaration]
+        'java' => %i[comment import_declaration],
+        'objc' => %i[comment import_declaration preproc_include]
       }.freeze
 
       attr_reader :parser, :language
@@ -52,17 +55,9 @@ module EmergeCLI
         extension = platform == 'darwin' ? 'dylib' : 'so'
         parser_file = "libtree-sitter-#{language}-#{platform}-#{arch}.#{extension}"
         parser_path = File.join('parsers', parser_file)
+        raise "No language grammar found for #{language}" unless File.exist?(parser_path)
 
-        case language
-        when 'swift'
-          @parser.language = TreeSitter::Language.load('swift', parser_path)
-        when 'kotlin'
-          @parser.language = TreeSitter::Language.load('kotlin', parser_path)
-        when 'java'
-          @parser.language = TreeSitter::Language.load('java', parser_path)
-        else
-          raise "Unsupported language: #{language}"
-        end
+        @parser.language = TreeSitter::Language.load(language, parser_path)
       end
 
       # Deletes a type from the given file contents.
@@ -127,6 +122,7 @@ module EmergeCLI
 
         while (node = nodes_to_process.shift)
           identifier_type = identifier_node_types.include?(node.type)
+          Logger.debug "Processing node: #{node.type} #{node_text(node)}"
           declaration_type = if node == tree.root_node
                                false
                              else
@@ -136,6 +132,11 @@ module EmergeCLI
             usages << { line: node.start_point.row, usage_type: 'declaration' }
           elsif identifier_type && node_text(node) == type_name
             usages << { line: node.start_point.row, usage_type: 'identifier' }
+          elsif node.type == :@implementation
+            next_sibling = node.next_named_sibling
+            if next_sibling.type == :identifier && node_text(next_sibling) == type_name
+              usages << { line: next_sibling.start_point.row, usage_type: 'declaration' }
+            end
           end
 
           node.each { |child| nodes_to_process.push(child) }
@@ -172,14 +173,14 @@ module EmergeCLI
 
         return file_contents if nodes_to_remove.empty?
 
-        Logger.debug "Found #{nodes_to_remove.length} nodes to remove"
+        Logger.debug "✅ Found #{nodes_to_remove.length} nodes to remove"
         remove_nodes_from_content(file_contents, nodes_to_remove)
       end
 
       private
 
       def remove_node(node, lines_to_remove)
-        Logger.debug "Removing node: #{node.type}"
+        Logger.debug "✅ Removing node: #{node.type}"
         start_position = node.start_point.row
         end_position = node.end_point.row
         lines_to_remove << { start: start_position, end: end_position }
@@ -287,7 +288,7 @@ module EmergeCLI
           when :navigation_expression # NetworkDebugger.printStats
             result = handle_navigation_expression(current)
             return result if result
-          when :class_declaration, :function_declaration, :method_declaration
+          when :class_declaration, :function_declaration, :method_declaration, :@implementation
             Logger.debug "Reached structural element, stopping at: #{current.type}"
             break
           end

data/lib/reaper/code_deleter.rb

@@ -163,7 +163,8 @@ module EmergeCLI
         found_usages = []
         source_patterns = case @platform&.downcase
                           when 'ios'
-                            { 'swift' => '**/*.swift' }
+                            { 'swift' => '**/*.swift',
+                              'objc' => '**/*.{m,h}' }
                           when 'android'
                             {
                               'kotlin' => '**/*.kt',
@@ -253,6 +254,7 @@ module EmergeCLI
                    when '.swift' then 'swift'
                    when '.kt' then 'kotlin'
                    when '.java' then 'java'
+                   when '.m', '.h' then 'objc'
                    else
                      raise "Unsupported file type for #{file_path}"
                    end

data/lib/utils/environment.rb

@@ -0,0 +1,7 @@
+module EmergeCLI
+  class Environment
+    def execute_command(command)
+      `#{command}`
+    end
+  end
+end

data/lib/utils/git.rb

@@ -3,6 +3,7 @@ require 'open3'
 module EmergeCLI
   module Git
     def self.branch
+      Logger.debug 'Getting current branch name'
       command = 'git rev-parse --abbrev-ref HEAD'
       Logger.debug command
       stdout, _, status = Open3.capture3(command)
@@ -39,6 +40,7 @@ module EmergeCLI
     end
 
     def self.sha
+      Logger.debug 'Getting current SHA'
       command = 'git rev-parse HEAD'
       Logger.debug command
       stdout, _, status = Open3.capture3(command)
@@ -46,6 +48,7 @@ module EmergeCLI
     end
 
     def self.base_sha
+      Logger.debug 'Getting base SHA'
       current_branch = branch
       remote_head = remote_head_branch
       return nil if current_branch.nil? || remote_head.nil?
@@ -59,6 +62,7 @@ module EmergeCLI
     end
 
     def self.previous_sha
+      Logger.debug 'Getting previous SHA'
       command = 'git rev-list --count HEAD'
       Logger.debug command
       count_stdout, _, count_status = Open3.capture3(command)
@@ -78,12 +82,14 @@ module EmergeCLI
     end
 
     def self.primary_remote
+      Logger.debug 'Getting primary remote'
       remote = remote()
       return nil if remote.nil?
       remote.include?('origin') ? 'origin' : remote.first
     end
 
     def self.remote_head_branch(remote = primary_remote)
+      Logger.debug 'Getting remote head branch'
       return nil if remote.nil?
       command = "git remote show #{remote}"
       Logger.debug command
@@ -98,6 +104,7 @@ module EmergeCLI
     end
 
     def self.remote_url(remote = primary_remote)
+      Logger.debug 'Getting remote URL'
       return nil if remote.nil?
       command = "git config --get remote.#{remote}.url"
       Logger.debug command
@@ -106,6 +113,7 @@ module EmergeCLI
     end
 
     def self.remote
+      Logger.debug 'Getting remote'
       command = 'git remote'
       Logger.debug command
       stdout, _, status = Open3.capture3(command)

data/lib/utils/network.rb

@@ -17,8 +17,8 @@ module EmergeCLI
       @internet = Async::HTTP::Internet.new
     end
 
-    def get(path:, headers: {}, max_retries: MAX_RETRIES)
-      request(:get, path, nil, headers, nil, max_retries)
+    def get(path:, headers: {}, query: nil, max_retries: MAX_RETRIES)
+      request(:get, path, nil, headers, query, max_retries)
     end
 
     def post(path:, body:, headers: {}, query: nil, max_retries: MAX_RETRIES)

data/lib/utils/xcode_device_manager.rb

@@ -0,0 +1,158 @@
+require 'json'
+require_relative 'xcode_simulator'
+require 'zip'
+require 'cfpropertylist'
+
+module EmergeCLI
+  class XcodeDeviceManager
+    class DeviceType
+      VIRTUAL = :virtual
+      PHYSICAL = :physical
+      ANY = :any
+    end
+
+    def initialize(environment: Environment.new)
+      @environment = environment
+    end
+
+    class << self
+      def get_supported_platforms(ipa_path)
+        return [] unless ipa_path&.end_with?('.ipa')
+
+        Zip::File.open(ipa_path) do |zip_file|
+          app_entry = zip_file.glob('**/*.app/').first ||
+                      zip_file.glob('**/*.app').first ||
+                      zip_file.find { |entry| entry.name.end_with?('.app/') || entry.name.end_with?('.app') }
+
+          raise 'No .app found in .ipa file' unless app_entry
+
+          app_dir = app_entry.name.end_with?('/') ? app_entry.name.chomp('/') : app_entry.name
+          info_plist_path = "#{app_dir}/Info.plist"
+          info_plist_entry = zip_file.find_entry(info_plist_path)
+          raise 'Info.plist not found in app bundle' unless info_plist_entry
+
+          info_plist_content = info_plist_entry.get_input_stream.read
+          plist = CFPropertyList::List.new(data: info_plist_content)
+          info_plist = CFPropertyList.native_types(plist.value)
+
+          info_plist['CFBundleSupportedPlatforms'] || []
+        end
+      end
+    end
+
+    def find_device_by_id(device_id)
+      Logger.debug "Looking for device with ID: #{device_id}"
+      devices_json = execute_command('xcrun xcdevice list')
+      devices_data = JSON.parse(devices_json)
+
+      found_device = devices_data.find { |device| device['identifier'] == device_id }
+      raise "No device found with ID: #{device_id}" unless found_device
+
+      device_type = found_device['simulator'] ? 'simulator' : 'physical'
+      Logger.info "✅ Found device: #{found_device['name']} " \
+                  "(#{found_device['identifier']}, #{device_type})"
+      if found_device['simulator']
+        XcodeSimulator.new(found_device['identifier'])
+      else
+        XcodePhysicalDevice.new(found_device['identifier'])
+      end
+    end
+
+    def find_device_by_type(device_type, ipa_path)
+      case device_type
+      when DeviceType::VIRTUAL
+        find_and_boot_most_recently_used_simulator
+      when DeviceType::PHYSICAL
+        find_connected_device
+      when DeviceType::ANY
+        # Check supported platforms in Info.plist to make intelligent choice
+        supported_platforms = self.class.get_supported_platforms(ipa_path)
+        Logger.debug "Build supports platforms: #{supported_platforms.join(', ')}"
+
+        if supported_platforms.include?('iPhoneOS')
+          device = find_connected_device
+          return device if device
+
+          # Only fall back to simulator if it's also supported
+          unless supported_platforms.include?('iPhoneSimulator')
+            raise 'Build only supports physical devices, but no device is connected'
+          end
+          Logger.info 'No physical device found, falling back to simulator since build supports both'
+          find_and_boot_most_recently_used_simulator
+
+        elsif supported_platforms.include?('iPhoneSimulator')
+          find_and_boot_most_recently_used_simulator
+        else
+          raise "Build doesn't support either physical devices or simulators"
+        end
+      end
+    end
+
+    private
+
+    def execute_command(command)
+      @environment.execute_command(command)
+    end
+
+    def find_connected_device
+      Logger.info 'Finding connected device...'
+      devices_json = execute_command('xcrun xcdevice list')
+      Logger.debug "Device list output: #{devices_json}"
+
+      devices_data = JSON.parse(devices_json)
+      physical_devices = devices_data
+                         .select do |device|
+        device['simulator'] == false &&
+          device['ignored'] == false &&
+          device['available'] == true &&
+          device['platform'] == 'com.apple.platform.iphoneos'
+      end
+
+      Logger.debug "Found physical devices: #{physical_devices}"
+
+      if physical_devices.empty?
+        Logger.info 'No physical connected device found'
+        return nil
+      end
+
+      device = physical_devices.first
+      Logger.info "Found connected physical device: #{device['name']} (#{device['identifier']})"
+      XcodePhysicalDevice.new(device['identifier'])
+    end
+
+    def find_and_boot_most_recently_used_simulator
+      Logger.info 'Finding and booting most recently used simulator...'
+      simulators_json = execute_command('xcrun simctl list devices --json')
+      Logger.debug "Simulators JSON: #{simulators_json}"
+
+      simulators_data = JSON.parse(simulators_json)
+
+      simulators = simulators_data['devices'].flat_map do |runtime, devices|
+        next [] unless runtime.include?('iOS') # Only include iOS devices
+
+        devices.select do |device|
+          (device['name'].start_with?('iPhone', 'iPad') &&
+            device['isAvailable'] &&
+            !device['isDeleted'])
+        end.map do |device|
+          version = runtime.match(/iOS-(\d+)-(\d+)/)&.captures&.join('.').to_f
+          last_booted = device['lastBootedAt'] ? Time.parse(device['lastBootedAt']) : Time.at(0)
+          [device['udid'], device['state'], version, last_booted]
+        end
+      end.sort_by { |_, _, _, last_booted| last_booted }.reverse
+
+      Logger.debug "Simulators: #{simulators}"
+
+      raise 'No available simulator found' unless simulators.any?
+
+      simulator_id, simulator_state, version, last_booted = simulators.first
+      version_str = version.zero? ? '' : " (#{version})"
+      last_booted_str = last_booted == Time.at(0) ? 'never' : last_booted.strftime('%Y-%m-%d %H:%M:%S')
+      Logger.info "Found simulator #{simulator_id}#{version_str} (#{simulator_state}, last booted: #{last_booted_str})"
+
+      simulator = XcodeSimulator.new(simulator_id, environment: @environment)
+      simulator.boot unless simulator_state == 'Booted'
+      simulator
+    end
+  end
+end

data/lib/utils/xcode_physical_device.rb

@@ -0,0 +1,108 @@
+require 'English'
+require 'timeout'
+require 'zip'
+require 'cfpropertylist'
+require 'fileutils'
+
+module EmergeCLI
+  class XcodePhysicalDevice
+    attr_reader :device_id
+
+    def initialize(device_id)
+      @device_id = device_id
+    end
+
+    def install_app(ipa_path)
+      raise "Non-IPA file provided: #{ipa_path}" unless ipa_path.end_with?('.ipa')
+
+      Logger.info "Installing app to device #{@device_id}..."
+
+      begin
+        # Set a timeout since I've noticed xcrun devicectl can occasionally hang for invalid apps
+        Timeout.timeout(60) do
+          command = "xcrun devicectl device install app --device #{@device_id} \"#{ipa_path}\""
+          Logger.debug "Running command: #{command}"
+
+          output = `#{command} 2>&1`
+          Logger.debug "Install command output: #{output}"
+
+          if output.include?('ERROR:') || output.include?('error:')
+            if output.include?('This provisioning profile cannot be installed on this device')
+              bundle_id = extract_bundle_id_from_error(output)
+              raise "Failed to install app: The provisioning profile for #{bundle_id} is not " \
+                    "valid for this device. Make sure the device's UDID is included in the " \
+                    'provisioning profile.'
+            elsif output.include?('Unable to Install')
+              error_message = output.match(/Unable to Install.*\n.*NSLocalizedRecoverySuggestion = ([^\n]+)/)&.[](1)
+              check_device_compatibility(ipa_path)
+              raise "Failed to install app: #{error_message || 'Unknown error'}"
+            else
+              check_device_compatibility(ipa_path)
+              raise "Failed to install app: #{output}"
+            end
+          end
+
+          success = $CHILD_STATUS.success?
+          unless success
+            check_device_compatibility(ipa_path)
+            raise "Installation failed with exit code #{$CHILD_STATUS.exitstatus}"
+          end
+        end
+      rescue Timeout::Error
+        raise 'Installation timed out after 30 seconds. The device might be locked or ' \
+              'installation might be stuck. Try unlocking the device and trying again.'
+      end
+
+      true
+    end
+
+    def launch_app(bundle_id)
+      command = "xcrun devicectl device process launch --device #{@device_id} #{bundle_id}"
+      Logger.debug "Running command: #{command}"
+
+      begin
+        Timeout.timeout(30) do
+          output = `#{command} 2>&1`
+          success = $CHILD_STATUS.success?
+
+          unless success
+            Logger.debug "Launch command output: #{output}"
+            if output.include?('The operation couldn\'t be completed. Application is restricted')
+              raise 'Failed to launch app: The app is restricted. Make sure the device is ' \
+                    'unlocked and the app is allowed to run.'
+            elsif output.include?('The operation couldn\'t be completed. Unable to launch')
+              raise 'Failed to launch app: Unable to launch. The app might be in a bad state - ' \
+                    'try uninstalling and reinstalling.'
+            else
+              raise "Failed to launch app #{bundle_id} on device: #{output}"
+            end
+          end
+        end
+      rescue Timeout::Error
+        raise 'Launch timed out after 30 seconds. The device might be locked. ' \
+              'Try unlocking the device and trying again.'
+      end
+
+      true
+    end
+
+    private
+
+    def check_device_compatibility(ipa_path)
+      supported_platforms = XcodeDeviceManager.get_supported_platforms(ipa_path)
+      Logger.debug "Supported platforms: #{supported_platforms.join(', ')}"
+
+      unless supported_platforms.include?('iPhoneOS')
+        raise 'This build is not compatible with physical devices. Please use a simulator ' \
+              'or make your build compatible with physical devices.'
+      end
+
+      Logger.debug 'Build is compatible with physical devices'
+    end
+
+    def extract_bundle_id_from_error(output)
+      # Extract bundle ID from error message like "...profile for com.emerge.hn.Hacker-News :"
+      output.match(/profile for ([\w\.-]+) :/)&.[](1) || 'unknown bundle ID'
+    end
+  end
+end