mysigner 0.1.0

data/lib/mysigner/upload/app_store_submission.rb

@@ -0,0 +1,312 @@
+require 'set'
+
+module Mysigner
+  module Upload
+    class AppStoreSubmission
+      class SubmissionError < Mysigner::Error; end
+
+      def initialize(client, organization_id, build_info, metadata_overrides: {}, override_sources: [])
+        @client = client
+        @organization_id = organization_id
+        @build_info = build_info # { bundle_id:, version:, build_number:, app_id:, build_id: }
+        @metadata_overrides = metadata_overrides || {}
+        @override_sources = Array(override_sources)
+        @override_lookup = build_override_lookup(@override_sources)
+      end
+
+      # Submit build for App Store review
+      def submit_for_review!(automation: nil)
+        puts ""
+        puts "📤 Preparing for App Store submission..."
+        puts ""
+        
+        begin
+          # Step 1: Fetch release metadata from My Signer API
+          merged = merge_metadata(fetch_release_metadata)
+          metadata = merged[:merged]
+          
+          if metadata && metadata.any?
+            puts "✓ Loaded release configuration from My Signer"
+            puts ""
+            display_metadata(metadata)
+          else
+            puts "⚠️  No release configuration found in My Signer"
+            puts "   Create one at: #{@client.api_url}/organizations/#{@organization_id}/app_store_releases"
+            puts ""
+          end
+          
+          # Enrich build_info with config values for smart build selection
+          enriched_build_info = symbolize_keys(@build_info)
+          if metadata
+            # min_build_number: skip builds below this number
+            if metadata['build_number'] && !enriched_build_info[:build_number]
+              enriched_build_info[:min_build_number] = metadata['build_number'].to_i
+            end
+            # Use version_string from config if not specified
+            if metadata['version_string'] && !enriched_build_info[:version]
+              enriched_build_info[:version] = metadata['version_string']
+            end
+          end
+          
+          automation_result = if automation
+            automation.perform!(
+              metadata: metadata,
+              build_info: enriched_build_info,
+              metadata_overrides: @metadata_overrides
+            )
+          else
+            guide_to_manual_submission(metadata)
+            nil
+          end
+
+          { success: true, metadata: metadata, automation: automation_result }
+          
+        rescue => e
+          raise SubmissionError, "Failed to prepare submission: #{e.message}"
+        end
+      end
+
+      private
+
+      def fetch_release_metadata
+        # Fetch release metadata from My Signer API
+        begin
+          response = @client.get(
+            "/api/v1/organizations/#{@organization_id}/app_store_releases",
+            params: { bundle_id: @build_info[:bundle_id] }
+          )
+          
+          if response[:success]
+            data = response[:data]
+            # API returns { app_store_releases: [...] } - extract first release
+            if data.is_a?(Hash) && data['app_store_releases'].is_a?(Array)
+              data['app_store_releases'].first
+            elsif data.is_a?(Hash) && data['app_store_release']
+              # Single release format
+              data['app_store_release']
+            else
+              data
+            end
+          else
+            nil
+          end
+        rescue Mysigner::NotFoundError
+          # No configuration found - that's okay
+          nil
+        rescue StandardError => e
+          puts "⚠️  Could not fetch release metadata: #{e.message}"
+          nil
+        end
+      end
+
+      # Fetch release config and extract min_build_number for smart build selection
+      def fetch_release_config
+        metadata = fetch_release_metadata
+        return {} unless metadata
+        
+        config = {}
+        config[:min_build_number] = metadata['build_number'].to_i if metadata['build_number']
+        config[:release_type] = metadata['release_type'] if metadata['release_type']
+        config[:earliest_release_date] = metadata['earliest_release_date'] if metadata['earliest_release_date']
+        config
+      end
+
+      def merge_metadata(api_metadata)
+        api_data = stringify_keys(api_metadata || {})
+        overrides = stringify_keys(@metadata_overrides)
+        {
+          merged: deep_merge(api_data, overrides),
+          api: api_data,
+          overrides: overrides
+        }
+      end
+
+      def guide_to_manual_submission(metadata)
+        puts "📋 Next Steps for App Store Submission"
+        puts "=" * 60
+        puts ""
+        puts "Your build is uploaded to App Store Connect!"
+        puts ""
+        puts "To submit for review:"
+        puts "  1. Wait for Apple to process the build (5-15 minutes)"
+        puts "  2. Open App Store Connect:"
+        puts "     https://appstoreconnect.apple.com"
+        puts "  3. Select your app and go to 'App Store' tab"
+        puts "  4. Create a new version or select existing one"
+        puts "  5. Select this build (#{@build_info[:version]} / #{@build_info[:build_number]})"
+        puts "  6. Add screenshots and metadata if not already present"
+        puts "  7. Click 'Submit for Review'"
+        puts ""
+
+        if metadata && metadata['auto_submit']
+          puts "💡 Auto-submit enabled"
+        end
+
+        puts ""
+        puts "Tip: rerun with --submit-for-review when ready"
+        puts "     Use --wait/--asc-timeout-seconds to control polling"
+        puts ""
+      end
+
+      def display_metadata(metadata)
+        puts "📝 Release Configuration:"
+        print_metadata_line('Bundle ID', metadata['bundle_identifier'], 'bundle_identifier')
+        print_metadata_line('App Name', metadata['app_name'], 'app_name') if metadata['app_name']
+        
+        # Version info from config
+        print_metadata_line('Version String', metadata['version_string'], 'version_string') if metadata['version_string']
+        print_metadata_line('Min Build #', metadata['build_number'], 'build_number') if metadata['build_number']
+
+        if metadata['whats_new'] && !metadata['whats_new'].to_s.strip.empty?
+          puts "   What's New: #{truncate(metadata['whats_new'])}#{override_suffix('whats_new')}"
+        else
+          puts "   What's New: —#{override_suffix('whats_new')}"
+        end
+        
+        if metadata['promotional_text'] && !metadata['promotional_text'].to_s.strip.empty?
+          puts "   Promo Text: #{truncate(metadata['promotional_text'])}#{override_suffix('promotional_text')}"
+        end
+
+        print_metadata_line('Support URL', metadata['support_url'], 'support_url')
+        print_metadata_line('Marketing URL', metadata['marketing_url'], 'marketing_url')
+        print_metadata_line('Privacy URL', metadata['privacy_policy_url'], 'privacy_policy_url')
+        
+        # Release settings
+        release_type_label = format_release_type(metadata['release_type'])
+        print_metadata_line('Release Type', release_type_label, 'release_type')
+        if metadata['release_type'] == 'SCHEDULED' && metadata['earliest_release_date']
+          print_metadata_line('Scheduled Date', metadata['earliest_release_date'], 'earliest_release_date')
+        end
+        
+        print_metadata_toggle('Auto-submit', metadata['auto_submit'], 'auto_submit')
+        print_metadata_toggle('Phased Release', metadata['phased_release'], 'phased_release')
+
+        if metadata['localizations'].is_a?(Array) && metadata['localizations'].any?
+          first_locale = metadata['localizations'].first
+          locale_code = first_locale['locale'] || first_locale['localeCode'] || 'default'
+          puts "   Localizations: #{metadata['localizations'].count} (showing #{locale_code})#{override_suffix('localizations')}"
+        end
+
+        warn_missing_submission_fields(metadata)
+        puts ""
+      end
+      
+      def format_release_type(release_type)
+        case release_type
+        when 'AFTER_APPROVAL' then 'After Approval (auto-release)'
+        when 'MANUAL' then 'Manual (hold for manual release)'
+        when 'SCHEDULED' then 'Scheduled'
+        else release_type || 'After Approval (default)'
+        end
+      end
+
+      def deep_merge(base, overrides)
+        merged = base.dup
+
+        overrides.each do |key, value|
+          merged[key] = if merged[key].is_a?(Hash) && value.is_a?(Hash)
+            deep_merge(merged[key], value)
+          else
+            value
+          end
+        end
+
+        merged
+      end
+
+      def stringify_keys(object)
+        case object
+        when Hash
+          object.each_with_object({}) do |(k, v), memo|
+            memo[k.to_s] = stringify_keys(v)
+          end
+        when Array
+          object.map { |item| stringify_keys(item) }
+        else
+          object
+        end
+      end
+
+      def symbolize_keys(object)
+        case object
+        when Hash
+          object.each_with_object({}) do |(k, v), memo|
+            memo[k.to_sym] = symbolize_keys(v)
+          end
+        when Array
+          object.map { |item| symbolize_keys(item) }
+        else
+          object
+        end
+      end
+
+      def truncate(text, max = 100)
+        text = text.to_s
+        return '—' if text.strip.empty?
+
+        text.length > max ? "#{text[0, max]}..." : text
+      end
+
+      def print_metadata_line(label, value, key)
+        display = value && !value.to_s.strip.empty? ? value : '—'
+        puts "   #{label}: #{display}#{override_suffix(key)}"
+      end
+
+      def print_metadata_toggle(label, value, key)
+        human = value.nil? ? '—' : (value ? 'Yes' : 'No')
+        puts "   #{label}: #{human}#{override_suffix(key)}"
+      end
+
+      def override_suffix(key)
+        sources = Array(@override_lookup[key])
+        return '' if sources.empty?
+
+        formatted = sources.map do |source|
+          case source[:type]
+          when :inline then 'CLI flag'
+          when :file
+            File.basename(source[:path])
+          else
+            source[:type].to_s
+          end
+        end.uniq
+
+        " (override: #{formatted.join(', ')})"
+      end
+
+      def build_override_lookup(sources)
+        lookup = Hash.new { |h, k| h[k] = [] }
+        sources.each do |source|
+          Array(source[:keys]).each do |key|
+            lookup[key] << source
+          end
+        end
+        lookup
+      end
+
+      def warn_missing_submission_fields(metadata)
+        return unless metadata['auto_submit']
+
+        # Get version to check if first version
+        version_string = metadata['version_string'] || metadata['version'] || '1.0'
+        is_first_version = version_string.split('.').first.to_i <= 1
+
+        warnings = []
+        # What's New only required for updates (version > 1.0)
+        warnings << "Missing What's New copy (required for version updates)" if !is_first_version && metadata['whats_new'].to_s.strip.empty?
+        
+        # Support URL may already be in App Store Connect, so just note it
+        if metadata['support_url'].to_s.strip.empty?
+          warnings << "Support URL not configured in My Signer (will use App Store Connect value if available)"
+        end
+
+        return if warnings.empty?
+
+        puts "   ⚠️  Notes:" unless warnings.empty?
+        warnings.each { |msg| puts "     - #{msg}" }
+      end
+    end
+  end
+end
+
+

data/lib/mysigner/upload/play_store_uploader.rb

@@ -0,0 +1,378 @@
+require 'json'
+require 'stringio'
+
+module Mysigner
+  module Upload
+    class PlayStoreUploader
+      class UploadError < Mysigner::Error; end
+      class CredentialsError < UploadError; end
+      class TrackError < UploadError; end
+      
+      # Special error for when AAB uploaded but track assignment failed
+      # This carries the version_code so it can be saved to prevent conflicts
+      class PartialUploadError < UploadError
+        attr_reader :version_code
+        
+        def initialize(message, version_code:)
+          super(message)
+          @version_code = version_code
+        end
+      end
+
+      VALID_TRACKS = %w[internal alpha beta production].freeze
+      SCOPE = 'https://www.googleapis.com/auth/androidpublisher'.freeze
+
+      def initialize(aab_path:, service_account_json:, package_name:)
+        @aab_path = File.expand_path(aab_path)
+        @service_account_json = service_account_json
+        @package_name = package_name
+
+        validate_aab!
+        setup_google_client!
+      end
+
+      # Upload AAB and optionally assign to a track
+      # @param track [String] Track to assign: internal, alpha, beta, production
+      # @param release_notes [Hash] Localized release notes { 'en-US' => 'What\'s new...' }
+      # @param user_fraction [Float] Rollout percentage (0.0-1.0) for staged rollouts
+      # @return [Hash] Upload result with version_code and track info
+      def upload!(track: 'internal', release_notes: nil, user_fraction: nil)
+        @current_track = track  # Store for error messages
+        say_uploading(track)
+
+        version_code = nil
+        
+        begin
+          # 1. Create an edit
+          edit = create_edit
+
+          # 2. Upload the AAB
+          bundle = upload_bundle(edit.id)
+          version_code = bundle.version_code
+
+          say_upload_success(version_code)
+
+          # 3. Assign to track with release
+          if track
+            assign_to_track(edit.id, track, version_code, release_notes: release_notes, user_fraction: user_fraction)
+          end
+
+          # 4. Commit the edit
+          commit_edit(edit.id)
+
+          say_success(track, version_code)
+
+          {
+            success: true,
+            version_code: version_code,
+            track: track,
+            package_name: @package_name
+          }
+        rescue Google::Apis::ClientError => e
+          error_message = parse_google_error(e)
+          # If AAB was uploaded, raise PartialUploadError so CLI can save the version
+          if version_code
+            raise PartialUploadError.new("Google Play API error: #{error_message}", version_code: version_code)
+          else
+            raise UploadError, "Google Play API error: #{error_message}"
+          end
+        rescue PartialUploadError
+          # Re-raise as-is
+          raise
+        rescue => e
+          if version_code
+            raise PartialUploadError.new("Upload failed: #{e.message}", version_code: version_code)
+          else
+            raise UploadError, "Upload failed: #{e.message}"
+          end
+        end
+      end
+
+      # Upload AAB only (without assigning to track)
+      def upload_bundle_only!
+        say_uploading(nil)
+
+        begin
+          edit = create_edit
+          bundle = upload_bundle(edit.id)
+          version_code = bundle.version_code
+
+          say_upload_success(version_code)
+
+          # Don't assign to track, just commit
+          commit_edit(edit.id)
+
+          {
+            success: true,
+            version_code: version_code,
+            package_name: @package_name
+          }
+        rescue Google::Apis::ClientError => e
+          error_message = parse_google_error(e)
+          raise UploadError, "Google Play API error: #{error_message}"
+        rescue => e
+          raise UploadError, "Upload failed: #{e.message}"
+        end
+      end
+
+      # Assign an existing version code to a track
+      def assign_existing_to_track!(version_code, track:, release_notes: nil, user_fraction: nil)
+        @current_track = track  # Store for error messages
+        begin
+          edit = create_edit
+          assign_to_track(edit.id, track, version_code, release_notes: release_notes, user_fraction: user_fraction)
+          commit_edit(edit.id)
+
+          {
+            success: true,
+            version_code: version_code,
+            track: track,
+            package_name: @package_name
+          }
+        rescue Google::Apis::ClientError => e
+          error_message = parse_google_error(e)
+          raise TrackError, "Failed to assign to track: #{error_message}"
+        end
+      end
+
+      private
+
+      def validate_aab!
+        unless File.exist?(@aab_path)
+          raise UploadError, "AAB file not found: #{@aab_path}"
+        end
+
+        unless @aab_path.end_with?('.aab')
+          raise UploadError, "Invalid file type: #{@aab_path} (must be .aab)"
+        end
+
+        file_size = File.size(@aab_path)
+        if file_size < 10_000
+          raise UploadError, "AAB file seems too small: #{file_size} bytes (possible corruption)"
+        end
+      end
+
+      def setup_google_client!
+        require 'googleauth'
+        require 'google/apis/androidpublisher_v3'
+
+        # Parse and validate service account JSON
+        begin
+          @credentials_data = JSON.parse(@service_account_json)
+        rescue JSON::ParserError => e
+          raise CredentialsError, "Invalid service account JSON: #{e.message}"
+        end
+
+        # Build authorization
+        @auth = Google::Auth::ServiceAccountCredentials.make_creds(
+          json_key_io: StringIO.new(@service_account_json),
+          scope: SCOPE
+        )
+
+        # Create service
+        @service = Google::Apis::AndroidpublisherV3::AndroidPublisherService.new
+        @service.authorization = @auth
+        @service.client_options.open_timeout_sec = 30
+        @service.client_options.read_timeout_sec = 300  # Large file uploads need time
+        @service.request_options.retries = 3
+
+      rescue LoadError => e
+        raise CredentialsError, "Google API client not installed. Run: gem install google-api-client"
+      end
+
+      def create_edit
+        edit = Google::Apis::AndroidpublisherV3::AppEdit.new
+        @service.insert_edit(@package_name, edit)
+      rescue Google::Apis::ClientError => e
+        if e.message.include?("Package not found") || e.status_code == 404
+          raise UploadError, first_upload_error_message
+        end
+        raise
+      end
+
+      def first_upload_error_message
+        <<~MSG
+          Google Play API can't find package '#{@package_name}'.
+
+          This happens when no build has been uploaded to this app yet.
+          Google Play API requires the FIRST build to be uploaded manually.
+
+          To fix:
+            1. Build AAB: mysigner android build
+            2. Go to Play Console → Your App → Internal testing → Create release
+            3. Upload the AAB file shown in the build output
+            4. Save the release (don't need to roll out)
+
+          After that, mysigner ship will work for all future uploads.
+        MSG
+      end
+
+      def upload_bundle(edit_id)
+        puts "📦 Uploading AAB (#{format_bytes(File.size(@aab_path))})..."
+        puts ""
+
+        begin
+          result = @service.upload_edit_bundle(
+            @package_name,
+            edit_id,
+            upload_source: @aab_path,
+            content_type: 'application/octet-stream'
+          )
+          result
+        rescue Google::Apis::ClientError => e
+          error_msg = parse_google_error(e)
+          raise UploadError, "Bundle upload failed: #{error_msg}"
+        rescue => e
+          raise UploadError, "Bundle upload failed: #{e.message}"
+        end
+      end
+
+      def assign_to_track(edit_id, track, version_code, release_notes: nil, user_fraction: nil)
+        unless VALID_TRACKS.include?(track)
+          raise TrackError, "Invalid track '#{track}'. Valid tracks: #{VALID_TRACKS.join(', ')}"
+        end
+
+        puts "🚂 Assigning to #{track} track..."
+
+        # Build release
+        release = Google::Apis::AndroidpublisherV3::TrackRelease.new(
+          version_codes: [version_code.to_s],
+          status: user_fraction ? 'inProgress' : 'completed'
+        )
+
+        # Add release notes if provided
+        if release_notes && release_notes.any?
+          release.release_notes = release_notes.map do |lang, text|
+            Google::Apis::AndroidpublisherV3::LocalizedText.new(
+              language: lang,
+              text: text
+            )
+          end
+        end
+
+        # Add user fraction for staged rollouts
+        if user_fraction
+          release.user_fraction = user_fraction
+        end
+
+        # Build track update
+        track_obj = Google::Apis::AndroidpublisherV3::Track.new(
+          track: track,
+          releases: [release]
+        )
+
+        @service.update_edit_track(@package_name, edit_id, track, track_obj)
+      end
+
+      def commit_edit(edit_id)
+        puts "💾 Committing changes..."
+        begin
+          # Try with changesNotSentForReview first (for apps without managed review)
+          @service.commit_edit(@package_name, edit_id, changes_not_sent_for_review: true)
+        rescue Google::Apis::ClientError => e
+          error_text = e.message.to_s
+          # Also check body if present
+          if e.respond_to?(:body) && e.body
+            error_text += " #{e.body}"
+          end
+          
+          if error_text.include?('changesNotSentForReview')
+            # App has managed review enabled, commit without the flag
+            @service.commit_edit(@package_name, edit_id)
+          else
+            raise
+          end
+        end
+      end
+
+      def parse_google_error(error)
+        begin
+          body = nil
+          if error.respond_to?(:body) && error.body
+            body = JSON.parse(error.body) rescue nil
+          end
+          
+          message = body&.dig('error', 'message') || error.message
+          details = body&.dig('error', 'errors')&.map { |e| e['message'] }&.join('; ')
+          full_message = details ? "#{message} (#{details})" : message
+          
+          # Provide helpful context for common errors
+          case full_message.to_s.downcase
+          when /package.*not found/i, /app not found/i
+            "#{full_message}\n\n💡 Make sure the package name '#{@package_name}' matches your app in Google Play Console."
+          when /not authorized/i, /permission denied/i, /forbidden/i
+            "#{full_message}\n\n💡 Check that your service account has Editor or Admin access to the app in Google Play Console."
+          when /version.*code.*already/i, /already.*used/i
+            "#{full_message}\n\n💡 Version code already exists. Increment versionCode in android/app/build.gradle and rebuild."
+          when /precondition.*check.*failed/i, /precondition.*failed/i
+            track_name = @current_track || "this track"
+            "#{full_message}\n\n" \
+            "💡 Google Play Console requires setup before publishing to #{track_name}:\n\n" \
+            "   For PRODUCTION track:\n" \
+            "   • Complete store listing (description, screenshots, etc.)\n" \
+            "   • Set content rating\n" \
+            "   • Configure pricing & distribution\n\n" \
+            "   For BETA/ALPHA tracks:\n" \
+            "   • Create a closed/open testing track in Play Console\n" \
+            "   • Add at least one tester email\n\n" \
+            "   For INTERNAL track:\n" \
+            "   • Add internal testers in Play Console\n\n" \
+            "   ✅ Your AAB was uploaded successfully!\n" \
+            "   → Go to Play Console to complete track setup, then use:\n" \
+            "     mysigner submit #{track_name} --platform android --version-code VERSION"
+          when /invalid request/i
+            "#{full_message}\n\n💡 Common causes:\n" \
+            "   • Version code not found on Google Play (must upload first)\n" \
+            "   • App not created in Google Play Console\n" \
+            "   • Service account missing permissions"
+          when /signing/i, /signature/i
+            "#{full_message}\n\n💡 The AAB may not be signed with the correct key. Check your keystore matches what's registered in Play Console."
+          else
+            full_message
+          end
+        rescue => parse_error
+          "#{error.message} (parsing error: #{parse_error.message})"
+        end
+      end
+
+      def say_uploading(track)
+        puts "☁️  Uploading to Google Play#{track ? " (#{track} track)" : ''}..."
+        puts ""
+        puts "AAB:         #{File.basename(@aab_path)}"
+        puts "Size:        #{format_bytes(File.size(@aab_path))}"
+        puts "Package:     #{@package_name}"
+        puts "Track:       #{track || 'none (upload only)'}"
+        puts ""
+      end
+
+      def say_upload_success(version_code)
+        puts "✓ Bundle uploaded successfully (version code: #{version_code})"
+        puts ""
+      end
+
+      def say_success(track, version_code)
+        puts ""
+        puts "=" * 80
+        puts "✓ Upload complete!"
+        puts "=" * 80
+        puts ""
+        puts "🎉 Your app is now on Google Play (#{track} track)"
+        puts ""
+        puts "Version Code: #{version_code}"
+        puts "Package:      #{@package_name}"
+        puts "Track:        #{track}"
+        puts ""
+      end
+
+      def format_bytes(bytes)
+        if bytes < 1024
+          "#{bytes} B"
+        elsif bytes < 1024 * 1024
+          "#{(bytes / 1024.0).round(1)} KB"
+        else
+          "#{(bytes / (1024.0 * 1024)).round(1)} MB"
+        end
+      end
+    end
+  end
+end