fastlane-plugin-luciq_agent_release_tracking 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd71cf314acb1b8ba7b76f6cd776d83658b1ec802e225690aaed727c28e7909f
+  data.tar.gz: c804f939bdb34491ea55433c52ca920b3ad4523faa4d4b44531f541257a676e3
+SHA512:
+  metadata.gz: 926f5ba839179d68847c3b33887f3dcc9bc97c5ee006b78d41708f96a1ec380d6bc67dd031acefbfdd0a57d84fd97853c948d8177f633f578ecb14efecf6ec1b
+  data.tar.gz: d1f6194fd71df8df8a9dcdc111a093fb0d6130b690aa62ec0796bb46746bd25ceb7afde25ff9ffa377021db132026bef9d975839a5b25000e0a280e5bb6216ac

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 yousif-ahmed <yousif.lasheen60@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,124 @@
+# luciq_agent_release_tracking plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-luciq_agent_release_tracking)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-luciq_agent_release_tracking`, add it to your project by running:
+
+```bash
+fastlane add_plugin luciq_agent_release_tracking
+```
+
+## About luciq_agent_release_tracking
+
+Luciq agent for tracking release builds and uploads to App Store and Play Store with comprehensive metadata reporting. This plugin provides custom actions that wrap the standard Fastlane actions and automatically report build and upload events to Luciq systems for better observability and integration into internal pipelines.
+
+### Available Actions
+
+- `luciq_build_ios_app` - Build iOS apps with Luciq agent reporting
+- `luciq_build_android_app` - Build Android apps with Luciq agent reporting
+- `luciq_upload_to_app_store` - Upload iOS builds to App Store with Luciq agent reporting
+- `luciq_upload_to_play_store` - Upload Android builds to Play Store with Luciq agent reporting
+
+### Features
+
+- Automatic reporting of build and upload events to Luciq
+- Branch-based tracking for comprehensive release observability
+- Integration with existing Fastlane workflows
+- Support for both iOS and Android platforms
+- Secure API communication with Luciq services
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+### Usage Examples
+
+#### iOS Build
+```ruby
+lane :build_ios do
+  luciq_build_ios_app(
+    branch_name: "main",
+    luciq_api_key: ENV["LUCIQ_API_KEY"],
+    workspace: "MyApp.xcworkspace",
+    scheme: "MyApp",
+    export_method: "app-store",
+    configuration: "Release"
+  )
+end
+```
+
+#### Android Build
+```ruby
+lane :build_android do
+  luciq_build_android_app(
+    branch_name: "main",
+    luciq_api_key: ENV["LUCIQ_API_KEY"],
+    task: "assembleRelease",
+    project_dir: "android/",
+    properties: {
+      "android.injected.signing.store.file" => "keystore.jks",
+      "android.injected.signing.store.password" => ENV["KEYSTORE_PASSWORD"],
+      "android.injected.signing.key.alias" => "key0",
+      "android.injected.signing.key.password" => ENV["KEY_PASSWORD"]
+    }
+  )
+end
+```
+
+#### iOS Upload
+```ruby
+lane :upload_ios do
+  luciq_upload_to_app_store(
+    branch_name: "main",
+    luciq_api_key: ENV["LUCIQ_API_KEY"],
+    ipa: "path/to/your/app.ipa",
+    skip_screenshots: true,
+    skip_metadata: true
+  )
+end
+```
+
+#### Android Upload
+```ruby
+lane :upload_android do
+  luciq_upload_to_play_store(
+    branch_name: "main",
+    luciq_api_key: ENV["LUCIQ_API_KEY"],
+    package_name: "com.example.app",
+    aab: "path/to/your/app.aab",
+    track: "internal",
+    skip_upload_screenshots: true
+  )
+end
+```
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/luciq_agent_release_tracking/actions/luciq_agent_release_tracking_action.rb

@@ -0,0 +1,47 @@
+require 'fastlane/action'
+require_relative '../helper/luciq_agent_release_tracking_helper'
+
+module Fastlane
+  module Actions
+    class LuciqAgentReleaseTrackingAction < Action
+      def self.run(params)
+        UI.message("The luciq_agent_release_tracking plugin is working!")
+      end
+
+      def self.description
+        "Luciq agent for tracking release builds and uploads to App Store and Play Store with comprehensive metadata reporting."
+      end
+
+      def self.authors
+        ["Luciq Company"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "This Fastlane plugin provides wrapper actions around the standard build and upload actions. It automatically reports build and upload events to the Luciq systems via secure HTTP requests. This allows engineering teams to track release pipeline steps per branch and platform with comprehensive observability and integration into internal systems."
+      end
+
+      def self.available_options
+        [
+          # FastlaneCore::ConfigItem.new(key: :your_option,
+          #                         env_name: "INSTABUG_STORES_UPLOAD_YOUR_OPTION",
+          #                      description: "A description of your option",
+          #                         optional: false,
+          #                             type: String)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/luciq_agent_release_tracking/actions/luciq_build_android_app_action.rb

@@ -0,0 +1,174 @@
+require 'fastlane/action'
+require_relative '../helper/luciq_agent_release_tracking_helper'
+
+module Fastlane
+  module Actions
+    class LuciqBuildAndroidAppAction < Action
+      def self.run(params)
+        UI.message("Starting Luciq Android build...")
+
+        # Extract Luciq-specific parameters
+        branch_name = params[:branch_name]
+        luciq_api_key = params[:luciq_api_key]
+
+        # Validate required parameters
+        if branch_name.nil? || branch_name.empty?
+          UI.user_error!("branch_name is required for Luciq reporting")
+        end
+
+        # Filter out Luciq-specific parameters before passing to gradle
+        filtered_params = Helper::LuciqAgentReleaseTrackingHelper.filter_luciq_params(params, Actions::GradleAction)
+
+        begin
+          # Report build start to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "inprogress",
+            step: "build_app"
+          )
+
+          # Start timing the build
+          build_start_time = Time.now
+
+          # Execute the actual Android build using gradle
+          result = Actions::GradleAction.run(filtered_params)
+
+          # Calculate build time in seconds
+          build_time = (Time.now - build_start_time).round
+
+          # Extract Android build path (APK or AAB)
+          build_path = fetch_android_build_path(Actions.lane_context)
+
+          if build_path.nil? || build_path.empty?
+            UI.user_error!("Could not find any generated APK or AAB. Please check your gradle settings.")
+          else
+            UI.success("Successfully found build artifact(s) at: #{build_path}")
+          end
+
+          # Report build success to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "success",
+            step: "build_app",
+            extras: {
+              build_time:,
+              build_path: Array(build_path)
+            }
+          )
+
+          UI.success("Android build completed successfully!")
+          result
+        rescue StandardError => e
+          error_message = Helper::LuciqAgentReleaseTrackingHelper.extract_error_message(e.message, :build_app)
+          UI.error("Android build failed: #{error_message}")
+
+          # Report build failure to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "failure",
+            step: "build_app",
+            error_message:
+          )
+          raise e
+        end
+      end
+
+      def self.description
+        "Build Android app with Luciq agent metadata reporting"
+      end
+
+      def self.authors
+        ["Luciq Company"]
+      end
+
+      def self.return_value
+        "Returns the result from gradle action"
+      end
+
+      def self.details
+        "This action wraps the standard gradle action and adds Luciq agent metadata reporting. It tracks build events per branch and provides better observability for engineering teams."
+      end
+
+      def self.available_options
+        # Start with the original gradle options
+        options = Actions::GradleAction.available_options
+
+        # Add Luciq-specific options
+        luciq_options = [
+          FastlaneCore::ConfigItem.new(
+            key: :branch_name,
+            env_name: "LUCIQ_BRANCH_NAME",
+            description: "The branch name for tracking builds",
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :luciq_api_key,
+            env_name: "LUCIQ_API_KEY",
+            description: "Luciq API key for reporting build events",
+            optional: false,
+            type: String,
+            sensitive: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :luciq_api_base_url,
+            env_name: "LUCIQ_API_BASE_URL",
+            description: "Luciq API base URL (defaults to https://api.instabug.com)",
+            optional: true,
+            type: String,
+            skip_type_validation: true # Since we don't extract this param
+          )
+        ]
+
+        # Combine both sets of options
+        options + luciq_options
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+
+      def self.example_code
+        [
+          'luciq_build_android_app(
+            branch_name: "main",
+            luciq_api_key: "your-api-key",
+            task: "assembleRelease",
+            project_dir: "android/",
+            properties: {
+              "android.injected.signing.store.file" => "keystore.jks",
+              "android.injected.signing.store.password" => "password",
+              "android.injected.signing.key.alias" => "key0",
+              "android.injected.signing.key.password" => "password"
+            }
+          )'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      # This helper method provides a clean and prioritized way to get the Android build output.
+      # It checks for the most common output types in a specific order.
+      # This is used to get the build path for the Android build artifact.
+      def self.fetch_android_build_path(lane_context)
+        build_keys = [
+          SharedValues::GRADLE_ALL_APK_OUTPUT_PATHS,
+          SharedValues::GRADLE_APK_OUTPUT_PATH,
+          SharedValues::GRADLE_ALL_AAB_OUTPUT_PATHS,
+          SharedValues::GRADLE_AAB_OUTPUT_PATH
+        ]
+        build_keys.each do |build_key|
+          build_path = lane_context[build_key]
+          return build_path if build_path && !build_path.empty?
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/luciq_agent_release_tracking/actions/luciq_build_ios_app_action.rb

@@ -0,0 +1,152 @@
+require 'fastlane/action'
+require_relative '../helper/luciq_agent_release_tracking_helper'
+
+module Fastlane
+  module Actions
+    class LuciqBuildIosAppAction < Action
+      def self.run(params)
+        UI.message("Starting Luciq iOS build...")
+
+        # Extract Luciq-specific parameters
+        branch_name = params[:branch_name]
+        luciq_api_key = params[:luciq_api_key]
+
+        # Validate required parameters
+        if branch_name.nil? || branch_name.empty?
+          UI.user_error!("branch_name is required for Luciq reporting")
+        end
+
+        # Filter out Luciq-specific parameters before passing to build_ios_app
+        filtered_params = Helper::LuciqAgentReleaseTrackingHelper.filter_luciq_params(params, Actions::BuildIosAppAction)
+
+        begin
+          # Report build start to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "inprogress",
+            step: "build_app"
+          )
+
+          # Start timing the build
+          build_start_time = Time.now
+
+          # Execute the actual iOS build
+          result = Actions::BuildIosAppAction.run(filtered_params)
+
+          # Calculate build time in seconds
+          build_time = (Time.now - build_start_time).round
+
+          # Extract IPA path from Fastlane environment
+          build_path = Actions.lane_context[SharedValues::IPA_OUTPUT_PATH]
+
+          if build_path
+            UI.success("IPA Output Path: #{build_path}")
+          else
+            UI.error("No IPA path found.")
+          end
+
+          # Report build success to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "success",
+            step: "build_app",
+            extras: {
+              build_time:,
+              build_path: Array(build_path)
+            }
+          )
+
+          UI.success("iOS build completed successfully!")
+          result
+        rescue StandardError => e
+          error_message = Helper::LuciqAgentReleaseTrackingHelper.extract_error_message(e.message, :build_app)
+          UI.error("iOS build failed: #{error_message}")
+
+          # Report build failure to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "failure",
+            step: "build_app",
+            error_message:
+          )
+          raise e
+        end
+      end
+
+      def self.description
+        "Build iOS app with Luciq agent metadata reporting"
+      end
+
+      def self.authors
+        ["Luciq Company"]
+      end
+
+      def self.return_value
+        "Returns the result from build_ios_app action"
+      end
+
+      def self.details
+        "This action wraps the standard build_ios_app action and adds Luciq agent metadata reporting. It tracks build events per branch and provides better observability for engineering teams."
+      end
+
+      def self.available_options
+        # Start with the original build_ios_app options
+        options = Actions::BuildIosAppAction.available_options
+
+        # Add Luciq-specific options
+        luciq_options = [
+          FastlaneCore::ConfigItem.new(
+            key: :branch_name,
+            env_name: "LUCIQ_BRANCH_NAME",
+            description: "The branch name for tracking builds",
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :luciq_api_key,
+            env_name: "LUCIQ_API_KEY",
+            description: "Luciq API key for reporting build events",
+            optional: false,
+            type: String,
+            sensitive: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :luciq_api_base_url,
+            env_name: "LUCIQ_API_BASE_URL",
+            description: "Luciq API base URL (defaults to https://api.instabug.com)",
+            optional: true,
+            type: String,
+            skip_type_validation: true # Since we don't extract this param
+          )
+        ]
+
+        # Combine both sets of options
+        options + luciq_options
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'luciq_build_ios_app(
+            branch_name: "main",
+            luciq_api_key: "your-api-key",
+            workspace: "MyApp.xcworkspace",
+            scheme: "MyApp",
+            export_method: "app-store",
+            configuration: "Release"
+          )'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/luciq_agent_release_tracking/actions/luciq_upload_to_app_store_action.rb

@@ -0,0 +1,155 @@
+require 'fastlane/action'
+require 'fastlane_core/ipa_file_analyser'
+require_relative '../helper/luciq_agent_release_tracking_helper'
+
+module Fastlane
+  module Actions
+    class LuciqUploadToAppStoreAction < Action
+      def self.run(params)
+        UI.message("Starting Luciq App Store upload...")
+
+        # Extract Luciq-specific parameters
+        branch_name = params[:branch_name]
+        luciq_api_key = params[:luciq_api_key]
+
+        # Validate required parameters
+        if branch_name.nil? || branch_name.empty?
+          UI.user_error!("branch_name is required for Luciq reporting")
+        end
+
+        # Filter out Luciq-specific parameters before passing to upload_to_app_store
+        filtered_params = Helper::LuciqAgentReleaseTrackingHelper.filter_luciq_params(params, Actions::UploadToAppStoreAction)
+
+        begin
+          # Report upload start to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "inprogress",
+            step: "upload_to_store"
+          )
+
+          # Execute the actual upload to App Store
+          result = Actions::UploadToAppStoreAction.run(filtered_params)
+
+          # Extract version information for iOS
+          version_string = detect_app_version(params)
+
+          # Report upload success to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "success",
+            step: "upload_to_store",
+            extras: {
+              version_string:
+            }.compact
+          )
+
+          UI.success("App Store upload completed successfully!")
+          result
+        rescue StandardError => e
+          error_message = Helper::LuciqAgentReleaseTrackingHelper.extract_error_message(e.message, :upload_to_store)
+
+          UI.error("App Store upload failed: #{error_message}")
+
+          # Report upload failure to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "failure",
+            step: "upload_to_store",
+            error_message:
+          )
+          raise e
+        end
+      end
+
+      def self.description
+        "Upload to App Store with Luciq agent metadata reporting"
+      end
+
+      def self.authors
+        ["Luciq Company"]
+      end
+
+      def self.return_value
+        "Returns the result from upload_to_app_store action"
+      end
+
+      def self.details
+        "This action wraps the standard upload_to_app_store action and adds Luciq agent metadata reporting. It tracks upload events per branch and provides better observability for engineering teams."
+      end
+
+      def self.available_options
+        # Start with the original upload_to_app_store options
+        options = Actions::UploadToAppStoreAction.available_options
+
+        # Add Luciq-specific options
+        luciq_options = [
+          FastlaneCore::ConfigItem.new(
+            key: :branch_name,
+            env_name: "LUCIQ_BRANCH_NAME",
+            description: "The branch name for tracking uploads",
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :luciq_api_key,
+            env_name: "LUCIQ_API_KEY",
+            description: "Luciq API key for reporting upload events",
+            optional: false,
+            type: String,
+            sensitive: true
+          )
+        ]
+
+        # Combine both sets of options
+        options + luciq_options
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'luciq_upload_to_app_store(
+            branch_name: "main",
+            luciq_api_key: "your-api-key",
+            ipa: "path/to/your.ipa",
+            skip_screenshots: true,
+            skip_metadata: true
+          )'
+        ]
+      end
+
+      def self.category
+        :app_store_connect
+      end
+
+      # Detect app version
+      def self.detect_app_version(params)
+        return params[:app_version] if params[:app_version]
+
+        ipa = params[:ipa] || Actions.lane_context[SharedValues::IPA_OUTPUT_PATH]
+        return nil unless ipa && File.exist?(ipa)
+
+        begin
+          version = FastlaneCore::IpaFileAnalyser.fetch_app_version(ipa)
+
+          if version.to_s.strip.empty?
+            UI.error("Could not extract version from IPA")
+            return nil
+          end
+
+          UI.success("Found app version: #{version}")
+          version
+        rescue StandardError => e
+          UI.verbose("Could not extract version from IPA: #{e.message}")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/luciq_agent_release_tracking/actions/luciq_upload_to_play_store_action.rb

@@ -0,0 +1,172 @@
+require 'fastlane/action'
+require_relative '../helper/luciq_agent_release_tracking_helper'
+
+module Fastlane
+  module Actions
+    class LuciqUploadToPlayStoreAction < Action
+      def self.run(params)
+        UI.message("Starting Luciq Play Store upload...")
+
+        # Extract Luciq-specific parameters
+        branch_name = params[:branch_name]
+        luciq_api_key = params[:luciq_api_key]
+
+        # Validate required parameters
+        if branch_name.nil? || branch_name.empty?
+          UI.user_error!("branch_name is required for Luciq reporting")
+        end
+
+        # Filter out Luciq-specific parameters before passing to upload_to_play_store
+        filtered_params = Helper::LuciqAgentReleaseTrackingHelper.filter_luciq_params(params, Actions::UploadToPlayStoreAction)
+
+        begin
+          # Report upload start to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "inprogress",
+            step: "upload_to_store"
+          )
+
+          # Execute the actual upload to Play Store
+          result = Actions::UploadToPlayStoreAction.run(filtered_params)
+
+          # Extract version information for Android
+          version_code = detect_version_code(params)
+
+          # Report upload success to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "success",
+            step: "upload_to_store",
+            extras: {
+              version_code:
+            }.compact
+          )
+
+          UI.success("Play Store upload completed successfully!")
+          result
+        rescue StandardError => e
+          error_message = Helper::LuciqAgentReleaseTrackingHelper.extract_error_message(e.message, :upload_to_store)
+          UI.error("Play Store upload failed: #{error_message}")
+
+          # Report upload failure to Luciq
+          Helper::LuciqAgentReleaseTrackingHelper.report_status(
+            branch_name:,
+            api_key: luciq_api_key,
+            status: "failure",
+            step: "upload_to_store",
+            error_message:
+          )
+          raise e
+        end
+      end
+
+      def self.description
+        "Upload to Play Store with Luciq agent metadata reporting"
+      end
+
+      def self.authors
+        ["Luciq Company"]
+      end
+
+      def self.return_value
+        "Returns the result from upload_to_play_store action"
+      end
+
+      def self.details
+        "This action wraps the standard upload_to_play_store action and adds Luciq agent metadata reporting. It tracks upload events per branch and provides better observability for engineering teams."
+      end
+
+      def self.available_options
+        # Start with the original upload_to_play_store options
+        options = Actions::UploadToPlayStoreAction.available_options
+
+        # Add Luciq-specific options
+        luciq_options = [
+          FastlaneCore::ConfigItem.new(
+            key: :branch_name,
+            env_name: "LUCIQ_BRANCH_NAME",
+            description: "The branch name for tracking uploads",
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :luciq_api_key,
+            env_name: "LUCIQ_API_KEY",
+            description: "Luciq API key for reporting upload events",
+            optional: false,
+            type: String,
+            sensitive: true
+          )
+        ]
+
+        # Combine both sets of options
+        options + luciq_options
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+
+      def self.example_code
+        [
+          'luciq_upload_to_play_store(
+            branch_name: "main",
+            luciq_api_key: "your-api-key",
+            package_name: "com.example.app",
+            aab: "path/to/your.aab",
+            track: "internal",
+            skip_upload_screenshots: true
+          )'
+        ]
+      end
+
+      def self.category
+        :google_play_console
+      end
+
+      def self.detect_version_code(params)
+        return params[:version_code] if params[:version_code]
+
+        UI.message("Fetching latest version code from Google Play Console...")
+
+        begin
+          # Build parameters hash
+          google_play_params = build_google_play_params(params)
+
+          version_codes = Actions::GooglePlayTrackVersionCodesAction.run(google_play_params)
+
+          if version_codes&.any?
+            latest_version = version_codes.first
+            UI.success("Found latest version code: #{latest_version}")
+            latest_version
+          else
+            UI.error("No version codes found on Google Play")
+            nil
+          end
+        rescue StandardError => e
+          UI.error("Failed to fetch from Google Play: #{e.message}")
+          nil
+        end
+      end
+
+      # Build parameters for google_play_track_version_codes action
+      def self.build_google_play_params(params)
+        google_params = {
+          package_name: params[:package_name],
+          track: params[:track] || 'production'
+        }
+
+        # Add authentication parameters
+        auth_keys = %i[key issuer json_key json_key_data root_url timeout]
+        auth_keys.each do |key|
+          google_params[key] = params[key]
+        end
+
+        google_params.compact
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/luciq_agent_release_tracking/helper/luciq_agent_release_tracking_helper.rb

@@ -0,0 +1,112 @@
+require 'fastlane_core/ui/ui'
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class LuciqAgentReleaseTrackingHelper
+      # Default Base URL for Luciq API
+      DEFAULT_LUCIQ_API_BASE_URL = "https://api.instabug.com".freeze
+      LUCIQ_KEYS = %i[branch_name luciq_api_key luciq_api_base_url].freeze
+      FASTLANE_ERROR_MESSAGE = {
+        build_app: "Your build was triggered but failed during execution. This could be due to missing environment variables or incorrect build credentials. Check CI logs for full details.",
+        upload_to_store: "Something went wrong while uploading your build. Check your Fastlane run for more details."
+      }
+
+      # Extract the important part of an error message
+      def self.extract_error_message(error_message, step)
+        return error_message unless error_message.kind_of?(String)
+
+        lines = error_message.split("\n")
+        start_index = lines.find_index { |line| line.strip.start_with?("* What went wrong:") }
+        end_index   = lines.find_index { |line| line.strip.start_with?("* Try:") }
+
+        if start_index && end_index && end_index > start_index
+          extracted_lines = lines[(start_index + 1)...end_index].map(&:strip).reject(&:empty?)
+          return extracted_lines.join(" ")[0, 250] unless extracted_lines.empty?
+        end
+
+        # Fallback message
+        FASTLANE_ERROR_MESSAGE[step]
+      end
+
+      def self.show_message
+        UI.message("Hello from the luciq_agent_release_tracking plugin helper!")
+      end
+
+      # Filters out Luciq-specific parameters from the params configuration
+      # and returns a new FastlaneCore::Configuration object with only the target action's parameters
+      def self.filter_luciq_params(params, target_action_class)
+        filtered_config = {}
+        params.available_options.each do |option|
+          key = option.key
+          filtered_config[key] = params[key] unless LUCIQ_KEYS.include?(key)
+        end
+
+        FastlaneCore::Configuration.create(target_action_class.available_options, filtered_config)
+      end
+
+      def self.report_status(branch_name:, api_key:, status:, step:, extras: {}, error_message: nil)
+        return unless branch_name.start_with?('crash-fix/instabug-crash-')
+
+        UI.message("📡 Reporting #{step} status to Luciq for #{branch_name}/#{status}")
+
+        make_api_request(
+          branch_name:,
+          status:,
+          api_key:,
+          step:,
+          extras:,
+          error_message:
+        )
+      end
+
+      def self.make_api_request(branch_name:, status:, api_key:, step:, extras: {}, error_message: nil)
+        return unless api_key
+
+        # Determine API base URL from env var or default
+        base_url = ENV['LUCIQ_API_BASE_URL'] || DEFAULT_LUCIQ_API_BASE_URL
+        uri = URI.parse("#{base_url}/api/web/public/agent_fastlane/status")
+
+        payload = {
+          branch_name:,
+          status:,
+          step:,
+          extras:,
+          error_message:
+        }
+
+        begin
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.read_timeout = 30
+          http.open_timeout = 30
+
+          request = Net::HTTP::Patch.new(uri.path)
+          request['Content-Type'] = 'application/json'
+          request['Authorization'] = "Bearer #{api_key}"
+          request['User-Agent'] = "fastlane-plugin-luciq_agent_release_tracking"
+          request.body = payload.to_json
+
+          response = http.request(request)
+
+          case response.code.to_i
+          when 200..299
+            UI.success("✅ Successfully reported to Luciq")
+          else
+            UI.error("❌ Unknown error reporting to Luciq: #{response.code} #{response.message}")
+          end
+        rescue Net::TimeoutError
+          UI.error("❌ Timeout while reporting to Luciq")
+        rescue Net::OpenTimeout
+          UI.error("❌ Connection timeout while reporting to Luciq")
+        rescue StandardError => e
+          UI.error("❌ Error reporting to Luciq: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/luciq_agent_release_tracking/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module LuciqAgentReleaseTracking
+    VERSION = "0.1.0"
+  end
+end

data/lib/fastlane/plugin/luciq_agent_release_tracking.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/luciq_agent_release_tracking/version'
+
+module Fastlane
+  module LuciqAgentReleaseTracking
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::LuciqAgentReleaseTracking.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-luciq_agent_release_tracking
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Luciq
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.228.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.228.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.50.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.50.2
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-require_tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email: support@luciq.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/luciq_agent_release_tracking.rb
+- lib/fastlane/plugin/luciq_agent_release_tracking/actions/luciq_agent_release_tracking_action.rb
+- lib/fastlane/plugin/luciq_agent_release_tracking/actions/luciq_build_android_app_action.rb
+- lib/fastlane/plugin/luciq_agent_release_tracking/actions/luciq_build_ios_app_action.rb
+- lib/fastlane/plugin/luciq_agent_release_tracking/actions/luciq_upload_to_app_store_action.rb
+- lib/fastlane/plugin/luciq_agent_release_tracking/actions/luciq_upload_to_play_store_action.rb
+- lib/fastlane/plugin/luciq_agent_release_tracking/helper/luciq_agent_release_tracking_helper.rb
+- lib/fastlane/plugin/luciq_agent_release_tracking/version.rb
+homepage: https://github.com/Instabug/fastlane-plugin-instabug-stores-upload
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Luciq agent for tracking release builds and uploads to App Store and Play
+  Store with comprehensive metadata reporting.
+test_files: []