feat(build): Add CLI parameters to track plugin versions (EME-XXX)

Add support for tracking Gradle and Fastlane plugin versions in build
uploads by accepting them as CLI parameters and writing them to the
metadata file in the uploaded zip archive.

This enables the backend to store plugin version information in the
PreprodArtifact database table for size analysis and build distribution
tracking.

Changes:
- Add --gradle-plugin-version and --fastlane-plugin-version CLI parameters
- Write plugin versions to .sentry-cli-metadata.txt in uploaded zips
- Update write_version_metadata() to accept optional plugin versions
- Add test coverage for metadata file generation with plugin versions

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: runningcode

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Improvements
 
+- The `sentry-cli build upload` command now accepts `--gradle-plugin-version` and `--fastlane-plugin-version` parameters to track plugin versions ([#2994](https://github.com/getsentry/sentry-cli/pull/2994)). These versions are written to the `.sentry-cli-metadata.txt` file in uploaded build archives, enabling the backend to store plugin version information for size analysis and build distribution tracking.
 - The `sentry-cli build upload` command now automatically detects the correct branch or tag reference in non-PR GitHub Actions workflows ([#2976](https://github.com/getsentry/sentry-cli/pull/2976)). Previously, `--head-ref` was only auto-detected for pull request workflows. Now it works for push, release, and other workflow types by using the `GITHUB_REF_NAME` environment variable.
 
 ## 2.58.2

src/commands/build/upload.rs

@@ -106,6 +106,16 @@ pub fn make_command(command: Command) -> Command {
                 .long("release-notes")
                 .help("The release notes to use for the upload.")
         )
+        .arg(
+            Arg::new("gradle_plugin_version")
+                .long("gradle-plugin-version")
+                .help("The version of the Sentry Gradle plugin used to build the artifact.")
+        )
+        .arg(
+            Arg::new("fastlane_plugin_version")
+                .long("fastlane-plugin-version")
+                .help("The version of the Sentry Fastlane plugin used to build the artifact.")
+        )
 }
 
 pub fn execute(matches: &ArgMatches) -> Result<()> {
@@ -280,6 +290,10 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
 
     let build_configuration = matches.get_one("build_configuration").map(String::as_str);
     let release_notes = matches.get_one("release_notes").map(String::as_str);
+    let gradle_plugin_version = matches.get_one("gradle_plugin_version").map(String::as_str);
+    let fastlane_plugin_version = matches
+        .get_one("fastlane_plugin_version")
+        .map(String::as_str);
 
     let api = Api::current();
     let authenticated_api = api.authenticated()?;
@@ -302,15 +316,22 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
 
         let normalized_zip = if path.is_file() {
             debug!("Normalizing file: {}", path.display());
-            handle_file(path, &byteview)?
+            handle_file(
+                path,
+                &byteview,
+                gradle_plugin_version,
+                fastlane_plugin_version,
+            )?
         } else if path.is_dir() {
             debug!("Normalizing directory: {}", path.display());
-            handle_directory(path).with_context(|| {
-                format!(
-                    "Failed to generate uploadable bundle for directory {}",
-                    path.display()
-                )
-            })?
+            handle_directory(path, gradle_plugin_version, fastlane_plugin_version).with_context(
+                || {
+                    format!(
+                        "Failed to generate uploadable bundle for directory {}",
+                        path.display()
+                    )
+                },
+            )?
         } else {
             Err(anyhow!(
                 "Path {} is neither a file nor a directory, cannot upload",
@@ -400,18 +421,31 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
     Ok(())
 }
 
-fn handle_file(path: &Path, byteview: &ByteView) -> Result<TempFile> {
+fn handle_file(
+    path: &Path,
+    byteview: &ByteView,
+    gradle_plugin_version: Option<&str>,
+    fastlane_plugin_version: Option<&str>,
+) -> Result<TempFile> {
     // Handle IPA files by converting them to XCArchive
     #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
     if is_zip_file(byteview) && is_ipa_file(byteview)? {
         debug!("Converting IPA file to XCArchive structure");
         let archive_temp_dir = TempDir::create()?;
         return ipa_to_xcarchive(path, byteview, &archive_temp_dir)
-            .and_then(|path| handle_directory(&path))
+            .and_then(|path| {
+                handle_directory(&path, gradle_plugin_version, fastlane_plugin_version)
+            })
             .with_context(|| format!("Failed to process IPA file {}", path.display()));
     }
 
-    normalize_file(path, byteview).with_context(|| {
+    normalize_file(
+        path,
+        byteview,
+        gradle_plugin_version,
+        fastlane_plugin_version,
+    )
+    .with_context(|| {
         format!(
             "Failed to generate uploadable bundle for file {}",
             path.display()
@@ -465,7 +499,12 @@ fn validate_is_supported_build(path: &Path, bytes: &[u8]) -> Result<()> {
 }
 
 // For APK and AAB files, we'll copy them directly into the zip
-fn normalize_file(path: &Path, bytes: &[u8]) -> Result<TempFile> {
+fn normalize_file(
+    path: &Path,
+    bytes: &[u8],
+    gradle_plugin_version: Option<&str>,
+    fastlane_plugin_version: Option<&str>,
+) -> Result<TempFile> {
     debug!("Creating normalized zip for file: {}", path.display());
 
     let temp_file = TempFile::create()?;
@@ -489,20 +528,29 @@ fn normalize_file(path: &Path, bytes: &[u8]) -> Result<TempFile> {
     zip.start_file(file_name, options)?;
     zip.write_all(bytes)?;
 
-    write_version_metadata(&mut zip)?;
+    write_version_metadata(&mut zip, gradle_plugin_version, fastlane_plugin_version)?;
 
     zip.finish()?;
     debug!("Successfully created normalized zip for file");
     Ok(temp_file)
 }
 
-fn handle_directory(path: &Path) -> Result<TempFile> {
+fn handle_directory(
+    path: &Path,
+    gradle_plugin_version: Option<&str>,
+    fastlane_plugin_version: Option<&str>,
+) -> Result<TempFile> {
     let temp_dir = TempDir::create()?;
     #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
     if is_apple_app(path)? {
         handle_asset_catalogs(path, temp_dir.path());
     }
-    normalize_directory(path, temp_dir.path())
+    normalize_directory(
+        path,
+        temp_dir.path(),
+        gradle_plugin_version,
+        fastlane_plugin_version,
+    )
 }
 
 /// Returns artifact url if upload was successful.
@@ -638,7 +686,7 @@ mod tests {
         fs::create_dir_all(test_dir.join("Products"))?;
         fs::write(test_dir.join("Products").join("app.txt"), "test content")?;
 
-        let result_zip = normalize_directory(&test_dir, temp_dir.path())?;
+        let result_zip = normalize_directory(&test_dir, temp_dir.path(), None, None)?;
         let zip_file = fs::File::open(result_zip.path())?;
         let mut archive = ZipArchive::new(zip_file)?;
         let file = archive.by_index(0)?;
@@ -654,7 +702,7 @@ mod tests {
         let xcarchive_path = Path::new("tests/integration/_fixtures/build/archive.xcarchive");
 
         // Process the XCArchive directory
-        let result = handle_directory(xcarchive_path)?;
+        let result = handle_directory(xcarchive_path, None, None)?;
 
         // Verify the resulting zip contains parsed assets
         let zip_file = fs::File::open(result.path())?;
@@ -687,7 +735,7 @@ mod tests {
         let byteview = ByteView::open(ipa_path)?;
 
         // Process the IPA file - this should work even without asset catalogs
-        let result = handle_file(ipa_path, &byteview)?;
+        let result = handle_file(ipa_path, &byteview, None, None)?;
 
         let zip_file = fs::File::open(result.path())?;
         let mut archive = ZipArchive::new(zip_file)?;
@@ -724,7 +772,7 @@ mod tests {
         let symlink_path = test_dir.join("Products").join("app_link.txt");
         symlink("app.txt", &symlink_path)?;
 
-        let result_zip = normalize_directory(&test_dir, temp_dir.path())?;
+        let result_zip = normalize_directory(&test_dir, temp_dir.path(), None, None)?;
         let zip_file = fs::File::open(result_zip.path())?;
         let mut archive = ZipArchive::new(zip_file)?;
 
@@ -757,4 +805,35 @@ mod tests {
         assert!(has_symlink, "Symlink should be preserved in zip");
         Ok(())
     }
+
+    #[test]
+    fn test_metadata_includes_plugin_versions() -> Result<()> {
+        let temp_dir = crate::utils::fs::TempDir::create()?;
+        let test_dir = temp_dir.path().join("TestApp.xcarchive");
+        fs::create_dir_all(test_dir.join("Products"))?;
+        fs::write(test_dir.join("Products").join("app.txt"), "test content")?;
+
+        let result_zip =
+            normalize_directory(&test_dir, temp_dir.path(), Some("4.12.0"), Some("1.2.3"))?;
+        let zip_file = fs::File::open(result_zip.path())?;
+        let mut archive = ZipArchive::new(zip_file)?;
+
+        // Find and read the metadata file
+        let metadata_file = archive.by_name(".sentry-cli-metadata.txt")?;
+        let metadata_content = std::io::read_to_string(metadata_file)?;
+
+        assert!(
+            metadata_content.contains("sentry-cli-version:"),
+            "Metadata should contain sentry-cli-version"
+        );
+        assert!(
+            metadata_content.contains("gradle-plugin-version: 4.12.0"),
+            "Metadata should contain gradle-plugin-version"
+        );
+        assert!(
+            metadata_content.contains("fastlane-plugin-version: 1.2.3"),
+            "Metadata should contain fastlane-plugin-version"
+        );
+        Ok(())
+    }
 }

src/utils/build/normalize.rs

@@ -94,17 +94,30 @@ fn metadata_file_options() -> SimpleFileOptions {
 
 pub fn write_version_metadata<W: std::io::Write + std::io::Seek>(
     zip: &mut ZipWriter<W>,
+    gradle_plugin_version: Option<&str>,
+    fastlane_plugin_version: Option<&str>,
 ) -> Result<()> {
     let version = get_version();
     zip.start_file(".sentry-cli-metadata.txt", metadata_file_options())?;
     writeln!(zip, "sentry-cli-version: {version}")?;
+    if let Some(gradle_version) = gradle_plugin_version {
+        writeln!(zip, "gradle-plugin-version: {gradle_version}")?;
+    }
+    if let Some(fastlane_version) = fastlane_plugin_version {
+        writeln!(zip, "fastlane-plugin-version: {fastlane_version}")?;
+    }
     Ok(())
 }
 
 // For XCArchive directories, we'll zip the entire directory
 // It's important to not change the contents of the directory or the size
 // analysis will be wrong and the code signature will break.
-pub fn normalize_directory(path: &Path, parsed_assets_path: &Path) -> Result<TempFile> {
+pub fn normalize_directory(
+    path: &Path,
+    parsed_assets_path: &Path,
+    gradle_plugin_version: Option<&str>,
+    fastlane_plugin_version: Option<&str>,
+) -> Result<TempFile> {
     debug!("Creating normalized zip for directory: {}", path.display());
 
     let temp_file = TempFile::create()?;
@@ -133,7 +146,7 @@ pub fn normalize_directory(path: &Path, parsed_assets_path: &Path) -> Result<Tem
         )?;
     }
 
-    write_version_metadata(&mut zip)?;
+    write_version_metadata(&mut zip, gradle_plugin_version, fastlane_plugin_version)?;
 
     zip.finish()?;
     debug!("Successfully created normalized zip for directory with {file_count} files");

tests/integration/_cases/build/build-upload-help-macos.trycmd

@@ -53,6 +53,10 @@ Options:
           be used.
       --release-notes <release_notes>
           The release notes to use for the upload.
+      --gradle-plugin-version <gradle_plugin_version>
+          The version of the Sentry Gradle plugin used to build the artifact.
+      --fastlane-plugin-version <fastlane_plugin_version>
+          The version of the Sentry Fastlane plugin used to build the artifact.
   -h, --help
           Print help