mysigner 0.1.0

data/lib/mysigner/build/android_executor.rb

@@ -0,0 +1,367 @@
+require 'fileutils'
+require 'tempfile'
+
+module Mysigner
+  module Build
+    class AndroidExecutor
+      class BuildError < StandardError; end
+
+      def initialize(project_info, parser)
+        @project_info = project_info
+        @parser = parser
+      end
+
+      # Build AAB (Android App Bundle) for Play Store
+      # Returns: path to .aab file
+      # Options:
+      #   - variant: Build variant (default: 'release')
+      #   - keystore_path: Path to keystore file
+      #   - keystore_password: Keystore password
+      #   - key_alias: Key alias in keystore
+      #   - key_password: Key password (defaults to keystore_password)
+      #   - version_code: Override version code (passed via gradle property)
+      def build_aab!(variant: 'release', keystore_path: nil, keystore_password: nil, key_alias: nil, key_password: nil, version_code: nil)
+        @variant = variant
+        @keystore_path = keystore_path
+        @keystore_password = keystore_password
+        @key_alias = key_alias
+        @key_password = key_password || keystore_password
+        @version_code = version_code
+
+        # Determine task name
+        task = "bundle#{variant.capitalize}"
+
+        # Build
+        success = run_gradle_build(task)
+
+        unless success
+          raise BuildError, "Android build failed. Check output above for errors."
+        end
+
+        # Find output AAB
+        aab_path = find_aab_output(variant)
+        
+        unless aab_path && File.exist?(aab_path)
+          raise BuildError, "Build reported success but AAB not found. Expected at: #{@parser.aab_output_path(variant)}"
+        end
+
+        aab_path
+      end
+
+      # Build APK
+      # Returns: path to .apk file
+      def build_apk!(variant: 'release', keystore_path: nil, keystore_password: nil, key_alias: nil, key_password: nil)
+        @variant = variant
+        @keystore_path = keystore_path
+        @keystore_password = keystore_password
+        @key_alias = key_alias
+        @key_password = key_password || keystore_password
+
+        # Determine task name
+        task = "assemble#{variant.capitalize}"
+
+        # Build
+        success = run_gradle_build(task)
+
+        unless success
+          raise BuildError, "Android build failed. Check output above for errors."
+        end
+
+        # Find output APK
+        apk_path = find_apk_output(variant)
+        
+        unless apk_path && File.exist?(apk_path)
+          raise BuildError, "Build reported success but APK not found. Expected at: #{@parser.apk_output_path(variant)}"
+        end
+
+        apk_path
+      end
+
+      # Clean build outputs
+      def clean!
+        run_gradle_command('clean')
+      end
+
+      private
+
+      def run_gradle_build(task)
+        # Ensure JAVA_HOME is valid
+        ensure_java_home!
+
+        # Handle framework-specific pre-build steps
+        run_pre_build_steps
+
+        # Build command with signing properties
+        cmd = build_gradle_command(task)
+
+        # Execute build
+        execute_with_output(cmd)
+      end
+
+      def ensure_java_home!
+        java_home = ENV['JAVA_HOME']
+
+        # Check if JAVA_HOME is set and valid
+        if java_home && !java_home.empty? && Dir.exist?(java_home)
+          # All good
+        else
+          # Try to detect valid JAVA_HOME
+          detected = detect_java_home
+          if detected
+            puts "🔧 Auto-detected JAVA_HOME: #{detected}"
+            ENV['JAVA_HOME'] = detected
+          elsif java_home && !java_home.empty?
+            raise BuildError, "JAVA_HOME is set to invalid directory: #{java_home}\n" \
+                             "Run 'mysigner doctor' to fix, or set JAVA_HOME manually:\n" \
+                             "  export JAVA_HOME=$(/usr/libexec/java_home -v 17)"
+          end
+        end
+
+        # Also ensure ANDROID_HOME is set
+        ensure_android_home!
+      end
+
+      def ensure_android_home!
+        android_home = ENV['ANDROID_HOME'] || ENV['ANDROID_SDK_ROOT']
+
+        # Check if already valid
+        if android_home && !android_home.empty? && Dir.exist?(android_home)
+          return
+        end
+
+        # Try to detect Android SDK
+        detected = detect_android_home
+        if detected
+          puts "🔧 Auto-detected ANDROID_HOME: #{detected}"
+          ENV['ANDROID_HOME'] = detected
+          ENV['ANDROID_SDK_ROOT'] = detected
+        else
+          raise BuildError, "Android SDK not found.\n" \
+                           "Run 'mysigner doctor' to diagnose, or set ANDROID_HOME:\n" \
+                           "  export ANDROID_HOME=~/Library/Android/sdk"
+        end
+      end
+
+      def detect_android_home
+        # Common SDK locations
+        candidates = [
+          File.expand_path('~/Library/Android/sdk'),
+          File.expand_path('~/Android/Sdk'),
+          '/opt/homebrew/share/android-commandlinetools',
+          '/usr/local/share/android-commandlinetools'
+        ]
+
+        candidates.each do |path|
+          return path if Dir.exist?(path) && Dir.exist?(File.join(path, 'platform-tools'))
+        end
+
+        nil
+      end
+
+      def detect_java_home
+        # Try macOS java_home utility first
+        if system('which /usr/libexec/java_home > /dev/null 2>&1')
+          java_home = `/usr/libexec/java_home 2>/dev/null`.strip
+          return java_home if !java_home.empty? && Dir.exist?(java_home)
+        end
+
+        # Try Homebrew paths (Apple Silicon)
+        %w[
+          /opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home
+          /opt/homebrew/opt/openjdk@21/libexec/openjdk.jdk/Contents/Home
+          /opt/homebrew/opt/openjdk/libexec/openjdk.jdk/Contents/Home
+        ].each { |p| return p if Dir.exist?(p) }
+
+        # Try Homebrew paths (Intel)
+        %w[
+          /usr/local/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home
+          /usr/local/opt/openjdk@21/libexec/openjdk.jdk/Contents/Home
+          /usr/local/opt/openjdk/libexec/openjdk.jdk/Contents/Home
+        ].each { |p| return p if Dir.exist?(p) }
+
+        # Try system Java
+        system_paths = Dir.glob('/Library/Java/JavaVirtualMachines/*/Contents/Home')
+        return system_paths.first if system_paths.any?
+
+        nil
+      end
+
+      def run_pre_build_steps
+        case @project_info[:framework]
+        when :capacitor
+          # Capacitor: sync before build
+          puts "🔄 Syncing Capacitor..."
+          Dir.chdir(@project_info[:directory]) do
+            system('npx cap sync android > /dev/null 2>&1')
+          end
+        when :react_native
+          # React Native: might need to install dependencies
+          if File.exist?(File.join(@project_info[:directory], 'node_modules'))
+            # Dependencies already installed
+          else
+            puts "📦 Installing npm dependencies..."
+            Dir.chdir(@project_info[:directory]) do
+              system('npm install > /dev/null 2>&1') || system('yarn install > /dev/null 2>&1')
+            end
+          end
+        when :flutter
+          # Flutter: ensure dependencies are fetched
+          puts "📦 Getting Flutter dependencies..."
+          Dir.chdir(@project_info[:directory]) do
+            system('flutter pub get > /dev/null 2>&1')
+          end
+        end
+      end
+
+      def build_gradle_command(task)
+        android_dir = @parser.android_directory
+        gradle_cmd = @parser.gradle_command
+
+        cmd_parts = []
+        
+        # Export JAVA_HOME if we detected/fixed it
+        java_home = ENV['JAVA_HOME']
+        if java_home && Dir.exist?(java_home)
+          cmd_parts << "export JAVA_HOME=#{shell_escape(java_home)}"
+          cmd_parts << "&&"
+        end
+
+        # Export ANDROID_HOME if we detected/fixed it
+        android_home = ENV['ANDROID_HOME']
+        if android_home && Dir.exist?(android_home)
+          cmd_parts << "export ANDROID_HOME=#{shell_escape(android_home)}"
+          cmd_parts << "&&"
+          cmd_parts << "export ANDROID_SDK_ROOT=#{shell_escape(android_home)}"
+          cmd_parts << "&&"
+        end
+        
+        # Change to android directory and run gradle
+        cmd_parts << "cd #{shell_escape(android_dir)}"
+        cmd_parts << "&&"
+        cmd_parts << gradle_cmd
+        cmd_parts << task
+
+        # Add signing properties if provided
+        if @keystore_path && File.exist?(@keystore_path)
+          cmd_parts << "-Pandroid.injected.signing.store.file=#{shell_escape(File.absolute_path(@keystore_path))}"
+          cmd_parts << "-Pandroid.injected.signing.store.password=#{shell_escape(@keystore_password)}" if @keystore_password
+          cmd_parts << "-Pandroid.injected.signing.key.alias=#{shell_escape(@key_alias)}" if @key_alias
+          cmd_parts << "-Pandroid.injected.signing.key.password=#{shell_escape(@key_password)}" if @key_password
+        end
+        
+        # Add version code override if provided (no file modification needed)
+        if @version_code
+          cmd_parts << "-PversionCode=#{@version_code}"
+        end
+
+        # Standard build options
+        cmd_parts << "--no-daemon"  # Avoid daemon issues in CI
+        cmd_parts << "-q"           # Quiet mode (less noise)
+
+        cmd_parts.join(' ')
+      end
+
+      def run_gradle_command(task)
+        android_dir = @parser.android_directory
+        gradle_cmd = @parser.gradle_command
+
+        exports = []
+        java_home = ENV['JAVA_HOME']
+        exports << "export JAVA_HOME=#{shell_escape(java_home)}" if java_home && Dir.exist?(java_home)
+        
+        android_home = ENV['ANDROID_HOME']
+        if android_home && Dir.exist?(android_home)
+          exports << "export ANDROID_HOME=#{shell_escape(android_home)}"
+          exports << "export ANDROID_SDK_ROOT=#{shell_escape(android_home)}"
+        end
+        
+        export_str = exports.any? ? exports.join(' && ') + ' && ' : ''
+        cmd = "#{export_str}cd #{shell_escape(android_dir)} && #{gradle_cmd} #{task} --no-daemon -q"
+        system(cmd)
+      end
+
+      def execute_with_output(cmd)
+        puts "🏗️  Running: gradle #{@variant}..."
+        puts ""
+
+        # Run command and capture output in real-time
+        IO.popen("#{cmd} 2>&1", 'r') do |io|
+          io.each_line do |line|
+            next if line.strip.empty?
+            
+            # Show errors and warnings
+            if line.include?('FAILURE') || line.include?('ERROR') || line.include?('error:')
+              puts line
+            elsif line.include?('warning:') || line.include?('WARNING')
+              puts line
+            # Show task progress
+            elsif line.include?('> Task') || line.include?('BUILD')
+              print '.'
+            # Show download progress
+            elsif line.include?('Download')
+              # Skip verbose download logs
+            end
+          end
+        end
+
+        puts "" # New line after dots
+
+        $?.success?
+      end
+
+      def find_aab_output(variant)
+        android_dir = @parser.android_directory
+        
+        # Search patterns for AAB files
+        patterns = [
+          File.join(android_dir, "app/build/outputs/bundle/#{variant}/*.aab"),
+          File.join(android_dir, "app/build/outputs/bundle/#{variant.downcase}/*.aab"),
+          File.join(android_dir, "build/outputs/bundle/#{variant}/*.aab"),
+          # Flutter uses different naming
+          File.join(android_dir, "app/build/outputs/bundle/#{variant}/app-#{variant}.aab"),
+          File.join(android_dir, "build/app/outputs/bundle/#{variant}/*.aab")
+        ]
+
+        patterns.each do |pattern|
+          matches = Dir.glob(pattern)
+          return matches.first if matches.any?
+        end
+
+        nil
+      end
+
+      def find_apk_output(variant)
+        android_dir = @parser.android_directory
+        
+        # Search patterns for APK files
+        patterns = [
+          File.join(android_dir, "app/build/outputs/apk/#{variant}/*.apk"),
+          File.join(android_dir, "app/build/outputs/apk/#{variant.downcase}/*.apk"),
+          File.join(android_dir, "build/outputs/apk/#{variant}/*.apk"),
+          File.join(android_dir, "app/build/outputs/apk/#{variant}/app-#{variant}.apk"),
+          # Unsigned APKs
+          File.join(android_dir, "app/build/outputs/apk/#{variant}/app-#{variant}-unsigned.apk")
+        ]
+
+        patterns.each do |pattern|
+          matches = Dir.glob(pattern)
+          return matches.first if matches.any?
+        end
+
+        nil
+      end
+
+      def shell_escape(str)
+        return "''" if str.nil? || str.empty?
+        
+        # If string contains no special characters, return as-is
+        if str =~ /\A[a-zA-Z0-9_.\-\/]+\z/
+          return str
+        end
+        
+        # Otherwise, quote it
+        "'" + str.gsub("'", "'\\''") + "'"
+      end
+    end
+  end
+end

data/lib/mysigner/build/android_parser.rb

@@ -0,0 +1,293 @@
+module Mysigner
+  module Build
+    class AndroidParser
+      attr_reader :project_info
+
+      def initialize(project_info)
+        @project_info = project_info
+        @gradle_content = read_gradle_file
+        @manifest_content = read_manifest_file
+      end
+
+      # Get the application ID (package name)
+      def application_id
+        # Try to extract from build.gradle
+        app_id = extract_from_gradle('applicationId')
+        return app_id if app_id
+
+        # Try namespace (newer Gradle)
+        namespace = extract_from_gradle('namespace')
+        return namespace if namespace
+
+        # Try Expo app.json (for Expo projects)
+        expo_package = extract_from_expo_config
+        return expo_package if expo_package
+
+        # Fallback to AndroidManifest.xml
+        extract_package_from_manifest
+      end
+
+      alias package_name application_id
+
+      # Get version code
+      def version_code
+        extract_from_gradle('versionCode')&.to_i
+      end
+
+      # Get version name
+      def version_name
+        extract_from_gradle('versionName')
+      end
+
+      # Get minimum SDK version
+      def min_sdk_version
+        extract_from_gradle('minSdk') || extract_from_gradle('minSdkVersion')
+      end
+
+      # Get target SDK version
+      def target_sdk_version
+        extract_from_gradle('targetSdk') || extract_from_gradle('targetSdkVersion')
+      end
+
+      # Get compile SDK version
+      def compile_sdk_version
+        extract_from_gradle('compileSdk') || extract_from_gradle('compileSdkVersion')
+      end
+
+      # Get all build types (debug, release, etc.)
+      def build_types
+        types = []
+        
+        # Match buildTypes block
+        if @gradle_content =~ /buildTypes\s*\{(.*?)\n\s*\}/m
+          block = $1
+          # Find all type names (e.g., "release {" or "debug {")
+          block.scan(/(\w+)\s*\{/) do |match|
+            types << match[0] unless %w[debug release].include?(match[0]) && types.include?(match[0])
+            types << match[0]
+          end
+        end
+        
+        # Default build types if none found
+        types = ['debug', 'release'] if types.empty?
+        types.uniq
+      end
+
+      # Get all product flavors
+      def product_flavors
+        flavors = []
+        
+        if @gradle_content =~ /productFlavors\s*\{(.*?)\n\s{4}\}/m
+          block = $1
+          block.scan(/(\w+)\s*\{/) do |match|
+            flavors << match[0]
+          end
+        end
+        
+        flavors
+      end
+
+      # Get signing config for a build type
+      def signing_config(build_type = 'release')
+        # Look for signingConfig in the build type block
+        if @gradle_content =~ /#{build_type}\s*\{[^}]*signingConfig\s*(?:=\s*)?signingConfigs\.(\w+)/m
+          return $1
+        end
+        nil
+      end
+
+      # Check if signing is configured for release builds
+      def signing_configured?(build_type = 'release')
+        signing_config(build_type) != nil
+      end
+
+      # Get signing configs defined in the project
+      def signing_configs
+        configs = []
+        
+        if @gradle_content =~ /signingConfigs\s*\{(.*?)\n\s{4}\}/m
+          block = $1
+          block.scan(/(\w+)\s*\{/) do |match|
+            configs << match[0]
+          end
+        end
+        
+        configs
+      end
+
+      # Get keystore path from signing config
+      def keystore_path(config_name = 'release')
+        if @gradle_content =~ /#{config_name}\s*\{[^}]*storeFile\s*(?:=\s*)?(?:file\()?"?([^")\n]+)"?\)?/m
+          return $1
+        end
+        nil
+      end
+
+      # Get keystore alias from signing config
+      def keystore_alias(config_name = 'release')
+        if @gradle_content =~ /#{config_name}\s*\{[^}]*keyAlias\s*(?:=\s*)?["']?([^"'\n]+)["']?/m
+          return $1.strip
+        end
+        nil
+      end
+
+      # Get the app name from strings.xml or manifest
+      def app_name
+        # Try strings.xml first
+        strings_path = File.join(android_directory, 'app/src/main/res/values/strings.xml')
+        if File.exist?(strings_path)
+          content = File.read(strings_path)
+          if content =~ /<string\s+name="app_name"[^>]*>([^<]+)<\/string>/
+            return $1
+          end
+        end
+
+        # Fallback to manifest label
+        if @manifest_content && @manifest_content =~ /android:label="([^"]+)"/
+          return $1
+        end
+
+        # Fallback to directory name
+        File.basename(@project_info[:directory])
+      end
+
+      # Check if project uses Kotlin DSL
+      def kotlin_dsl?
+        @project_info[:app_build_gradle]&.end_with?('.kts')
+      end
+
+      # Get the gradle wrapper command
+      def gradle_command
+        wrapper_path = File.join(android_directory, 'gradlew')
+        File.exist?(wrapper_path) ? './gradlew' : 'gradle'
+      end
+
+      # Check if gradle wrapper exists
+      def gradle_wrapper_exists?
+        File.exist?(File.join(android_directory, 'gradlew'))
+      end
+
+      # Get available build variants (build type + flavor combinations)
+      def build_variants
+        flavors = product_flavors
+        types = build_types
+
+        if flavors.empty?
+          types.map { |t| t }
+        else
+          flavors.flat_map do |flavor|
+            types.map { |type| "#{flavor}#{type.capitalize}" }
+          end
+        end
+      end
+
+      # Get AAB output path for a variant
+      def aab_output_path(variant = 'release')
+        # Standard output location
+        File.join(android_directory, "app/build/outputs/bundle/#{variant}/app-#{variant}.aab")
+      end
+
+      # Get APK output path for a variant
+      def apk_output_path(variant = 'release')
+        File.join(android_directory, "app/build/outputs/apk/#{variant}/app-#{variant}.apk")
+      end
+
+      # Get Android directory
+      def android_directory
+        @project_info[:android_directory] || @project_info[:path]
+      end
+
+      # Get project summary
+      def summary
+        {
+          application_id: application_id,
+          version_code: version_code,
+          version_name: version_name,
+          min_sdk: min_sdk_version,
+          target_sdk: target_sdk_version,
+          build_types: build_types,
+          product_flavors: product_flavors,
+          signing_configured: signing_configured?,
+          kotlin_dsl: kotlin_dsl?,
+          gradle_wrapper: gradle_wrapper_exists?
+        }
+      end
+
+      private
+
+      def read_gradle_file
+        gradle_path = @project_info[:app_build_gradle]
+        
+        unless gradle_path && File.exist?(gradle_path)
+          # Try to find it
+          android_dir = android_directory
+          gradle_path = File.join(android_dir, 'app/build.gradle')
+          gradle_path = File.join(android_dir, 'app/build.gradle.kts') unless File.exist?(gradle_path)
+          gradle_path = File.join(android_dir, 'build.gradle') unless File.exist?(gradle_path)
+          gradle_path = File.join(android_dir, 'build.gradle.kts') unless File.exist?(gradle_path)
+        end
+
+        return '' unless File.exist?(gradle_path)
+        File.read(gradle_path)
+      end
+
+      def read_manifest_file
+        manifest_path = File.join(android_directory, 'app/src/main/AndroidManifest.xml')
+        return nil unless File.exist?(manifest_path)
+        File.read(manifest_path)
+      end
+
+      def extract_from_gradle(property)
+        # Handle both Groovy and Kotlin DSL syntax
+        # Groovy: applicationId "com.example.app" or applicationId = "com.example.app"
+        # Kotlin: applicationId = "com.example.app"
+        
+        patterns = [
+          /#{property}\s*=?\s*["']([^"']+)["']/,
+          /#{property}\s+["']([^"']+)["']/,
+          /#{property}\s*=\s*(\d+)/,
+          /#{property}\s+(\d+)/
+        ]
+
+        patterns.each do |pattern|
+          if @gradle_content =~ pattern
+            return $1
+          end
+        end
+
+        nil
+      end
+
+      def extract_package_from_manifest
+        return nil unless @manifest_content
+        
+        if @manifest_content =~ /package="([^"]+)"/
+          return $1
+        end
+        
+        nil
+      end
+
+      def extract_from_expo_config
+        # Check for app.json in project root
+        project_dir = @project_info[:directory]
+        app_json_path = File.join(project_dir, 'app.json')
+        
+        return nil unless File.exist?(app_json_path)
+        
+        begin
+          require 'json'
+          config = JSON.parse(File.read(app_json_path))
+          
+          # Expo config can be nested under 'expo' key or at root
+          expo_config = config['expo'] || config
+          
+          # Get Android package name
+          expo_config.dig('android', 'package')
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end