sentry-cli 3.3.3__tar.gz → 3.3.4__tar.gz

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/Cargo.lock

@@ -3414,7 +3414,7 @@ dependencies = [
 
 [[package]]
 name = "sentry-cli"
-version = "3.3.3"
+version = "3.3.4"
 dependencies = [
  "anyhow",
  "anylog",

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 build = "build.rs"
 name = "sentry-cli"
-version = "3.3.3"
+version = "3.3.4"
 edition = "2021"
 rust-version = "1.91"
 

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry_cli
-Version: 3.3.3
+Version: 3.3.4
 Summary: A command line utility to work with Sentry.
 Home-page: https://github.com/getsentry/sentry-cli
 Author: Sentry

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/sentry_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry_cli
-Version: 3.3.3
+Version: 3.3.4
 Summary: A command line utility to work with Sentry.
 Home-page: https://github.com/getsentry/sentry-cli
 Author: Sentry

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/sentry_cli.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ src/api/envelopes_api.rs
 src/api/mod.rs
 src/api/pagination.rs
 src/api/serialization.rs
+src/api/data_types/code_mappings.rs
 src/api/data_types/deploy.rs
 src/api/data_types/mod.rs
 src/api/data_types/snapshots.rs
@@ -63,9 +64,12 @@ src/commands/update.rs
 src/commands/upload_dif.rs
 src/commands/upload_dsym.rs
 src/commands/upload_proguard.rs
+src/commands/build/download.rs
 src/commands/build/mod.rs
 src/commands/build/snapshots.rs
 src/commands/build/upload.rs
+src/commands/code_mappings/mod.rs
+src/commands/code_mappings/upload.rs
 src/commands/dart_symbol_map/mod.rs
 src/commands/dart_symbol_map/upload.rs
 src/commands/debug_files/bundle_jvm.rs

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/src/api/data_types/chunking/build.rs

@@ -28,6 +28,13 @@ pub struct AssembleBuildResponse {
     pub artifact_url: Option<String>,
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildInstallDetails {
+    pub is_installable: bool,
+    pub install_url: Option<String>,
+}
+
 /// VCS information for build app uploads
 #[derive(Debug, Serialize)]
 pub struct VcsInfo<'a> {

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/src/api/data_types/chunking/mod.rs

@@ -10,7 +10,7 @@ mod hash_algorithm;
 mod upload;
 
 pub use self::artifact::{AssembleArtifactsResponse, ChunkedArtifactRequest};
-pub use self::build::{AssembleBuildResponse, ChunkedBuildRequest, VcsInfo};
+pub use self::build::{AssembleBuildResponse, BuildInstallDetails, ChunkedBuildRequest, VcsInfo};
 pub use self::compression::ChunkCompression;
 pub use self::dif::{AssembleDifsRequest, AssembleDifsResponse, ChunkedDifRequest};
 pub use self::file_state::ChunkedFileState;

sentry_cli-3.3.4/src/api/data_types/code_mappings.rs

@@ -0,0 +1,37 @@
+//! Data types for the bulk code mappings API.
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BulkCodeMappingsRequest<'a> {
+    pub project: &'a str,
+    pub repository: &'a str,
+    pub default_branch: &'a str,
+    pub mappings: &'a [BulkCodeMapping],
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BulkCodeMapping {
+    pub stack_root: String,
+    pub source_root: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BulkCodeMappingsResponse {
+    pub created: u64,
+    pub updated: u64,
+    pub errors: u64,
+    pub mappings: Vec<BulkCodeMappingResult>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BulkCodeMappingResult {
+    pub stack_root: String,
+    pub source_root: String,
+    pub status: String,
+    #[serde(default)]
+    pub detail: Option<String>,
+}

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/src/api/data_types/mod.rs

@@ -1,9 +1,11 @@
 //! Data types used in the api module
 
 mod chunking;
+mod code_mappings;
 mod deploy;
 mod snapshots;
 
 pub use self::chunking::*;
+pub use self::code_mappings::*;
 pub use self::deploy::*;
 pub use self::snapshots::*;

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/src/api/data_types/snapshots.rs

@@ -7,7 +7,6 @@ use serde_json::Value;
 
 use super::VcsInfo;
 
-const IMAGE_FILE_NAME_FIELD: &str = "image_file_name";
 const WIDTH_FIELD: &str = "width";
 const HEIGHT_FIELD: &str = "height";
 
@@ -42,16 +41,7 @@ pub struct ImageMetadata {
 }
 
 impl ImageMetadata {
-    pub fn new(
-        image_file_name: String,
-        width: u32,
-        height: u32,
-        mut extra: HashMap<String, Value>,
-    ) -> Self {
-        extra.insert(
-            IMAGE_FILE_NAME_FIELD.to_owned(),
-            Value::String(image_file_name),
-        );
+    pub fn new(width: u32, height: u32, mut extra: HashMap<String, Value>) -> Self {
         extra.insert(WIDTH_FIELD.to_owned(), Value::from(width));
         extra.insert(HEIGHT_FIELD.to_owned(), Value::from(height));
 
@@ -68,18 +58,16 @@ mod tests {
     #[test]
     fn cli_managed_fields_override_sidecar_fields() {
         let extra = serde_json::from_value(json!({
-            (IMAGE_FILE_NAME_FIELD): "from-sidecar.png",
             (WIDTH_FIELD): 1,
             (HEIGHT_FIELD): 2,
             "custom": "keep-me"
         }))
         .unwrap();
 
-        let metadata = ImageMetadata::new("from-cli.png".to_owned(), 100, 200, extra);
+        let metadata = ImageMetadata::new(100, 200, extra);
         let serialized = serde_json::to_value(metadata).unwrap();
 
         let expected = json!({
-            (IMAGE_FILE_NAME_FIELD): "from-cli.png",
             (WIDTH_FIELD): 100,
             (HEIGHT_FIELD): 200,
             "custom": "keep-me"

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/src/api/mod.rs

@@ -16,7 +16,6 @@ use std::borrow::Cow;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::error::Error as _;
-#[cfg(any(target_os = "macos", not(feature = "managed")))]
 use std::fs::File;
 use std::io::{self, Read as _, Write};
 use std::rc::Rc;
@@ -724,6 +723,26 @@ impl AuthenticatedApi<'_> {
             .convert_rnf(ApiErrorKind::ProjectNotFound)
     }
 
+    pub fn get_build_install_details(
+        &self,
+        org: &str,
+        build_id: &str,
+    ) -> ApiResult<BuildInstallDetails> {
+        let url = format!(
+            "/organizations/{}/preprodartifacts/{}/install-details/",
+            PathArg(org),
+            PathArg(build_id)
+        );
+
+        self.get(&url)?.convert()
+    }
+
+    pub fn download_installable_build(&self, url: &str, dst: &mut File) -> ApiResult<ApiResponse> {
+        self.request(Method::Get, url)?
+            .progress_bar_mode(ProgressBarMode::Response)
+            .send_into(dst)
+    }
+
     /// List all organizations associated with the authenticated token
     /// in the given `Region`. If no `Region` is provided, we assume
     /// we're issuing a request to a monolith deployment.
@@ -978,6 +997,17 @@ impl AuthenticatedApi<'_> {
         Ok(rv)
     }
 
+    /// Bulk uploads code mappings for an organization.
+    pub fn bulk_upload_code_mappings(
+        &self,
+        org: &str,
+        body: &BulkCodeMappingsRequest,
+    ) -> ApiResult<BulkCodeMappingsResponse> {
+        let path = format!("/organizations/{}/code-mappings/bulk/", PathArg(org));
+        self.post(&path, body)?
+            .convert_rnf(ApiErrorKind::OrganizationNotFound)
+    }
+
     /// Creates a preprod snapshot artifact for the given project.
     pub fn create_preprod_snapshot<S: Serialize>(
         &self,

sentry_cli-3.3.4/src/commands/build/download.rs

@@ -0,0 +1,106 @@
+use std::fs;
+use std::path::PathBuf;
+
+use anyhow::{bail, Result};
+use clap::{Arg, ArgMatches, Command};
+use log::info;
+
+use crate::api::Api;
+use crate::config::Config;
+use crate::utils::args::ArgExt as _;
+use crate::utils::fs::TempFile;
+
+const EXPERIMENTAL_WARNING: &str =
+    "[EXPERIMENTAL] The \"build download\" command is experimental. \
+    The command is subject to breaking changes, including removal, in any Sentry CLI release.";
+
+pub fn make_command(command: Command) -> Command {
+    command
+        .about("[EXPERIMENTAL] Download a build artifact.")
+        .long_about(format!(
+            "Download a build artifact.\n\n{EXPERIMENTAL_WARNING}"
+        ))
+        .org_arg()
+        .arg(
+            Arg::new("build_id")
+                .long("build-id")
+                .short('b')
+                .required(true)
+                .help("The ID of the build to download."),
+        )
+        .arg(Arg::new("output").long("output").help(
+            "The output file path. Defaults to \
+                    'preprod_artifact_<build_id>.<ext>' in the current directory, \
+                    where ext is ipa or apk depending on the platform.",
+        ))
+}
+
+/// For iOS builds, the install URL points to a plist manifest.
+/// Replace the response_format to download the actual IPA binary instead.
+fn ensure_binary_format(url: &str) -> String {
+    url.replace("response_format=plist", "response_format=ipa")
+}
+
+/// Extract the file extension from the response_format query parameter.
+fn extension_from_url(url: &str) -> Result<&str> {
+    if url.contains("response_format=ipa") {
+        Ok("ipa")
+    } else if url.contains("response_format=apk") {
+        Ok("apk")
+    } else {
+        bail!("Unsupported build format in download URL.")
+    }
+}
+
+pub fn execute(matches: &ArgMatches) -> Result<()> {
+    eprintln!("{EXPERIMENTAL_WARNING}");
+    let config = Config::current();
+    let org = config.get_org(matches)?;
+    let build_id = matches
+        .get_one::<String>("build_id")
+        .expect("build_id is required");
+
+    let api = Api::current();
+    let authenticated_api = api.authenticated()?;
+
+    info!("Fetching install details for build {build_id}");
+    let details = authenticated_api.get_build_install_details(&org, build_id)?;
+
+    if !details.is_installable {
+        bail!("Build {build_id} is not installable.");
+    }
+
+    let install_url = details
+        .install_url
+        .ok_or_else(|| anyhow::anyhow!("Build {build_id} has no install URL."))?;
+
+    let download_url = ensure_binary_format(&install_url);
+
+    let output_path = match matches.get_one::<String>("output") {
+        Some(path) => PathBuf::from(path),
+        None => {
+            let ext = extension_from_url(&download_url)?;
+            PathBuf::from(format!("preprod_artifact_{build_id}.{ext}"))
+        }
+    };
+
+    info!("Downloading build {build_id} to {}", output_path.display());
+
+    let tmp = TempFile::create()?;
+    let mut file = tmp.open()?;
+    let response = authenticated_api.download_installable_build(&download_url, &mut file)?;
+
+    if response.failed() {
+        bail!(
+            "Failed to download build (server returned status {}).",
+            response.status()
+        );
+    }
+
+    drop(file);
+    fs::copy(tmp.path(), &output_path)?;
+
+    println!("Successfully downloaded build to {}", output_path.display());
+
+    Ok(())
+}

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/src/commands/build/mod.rs

@@ -3,11 +3,13 @@ use clap::{ArgMatches, Command};
 
 use crate::utils::args::ArgExt as _;
 
+pub mod download;
 pub mod snapshots;
 pub mod upload;
 
 macro_rules! each_subcommand {
     ($mac:ident) => {
+        $mac!(download);
         $mac!(snapshots);
         $mac!(upload);
     };

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/src/commands/build/snapshots.rs

@@ -331,11 +331,28 @@ fn upload_images(
 
     let mut many_builder = session.many();
     let mut manifest_entries = HashMap::new();
-    let image_count = images.len();
-
+    let mut collisions: HashMap<String, Vec<String>> = HashMap::new();
+    let mut kept_paths: HashMap<String, String> = HashMap::new();
     for image in images {
         debug!("Processing image: {}", image.path.display());
 
+        let image_file_name = image
+            .relative_path
+            .file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .into_owned();
+
+        let relative_path = crate::utils::fs::path_as_url(&image.relative_path);
+
+        if manifest_entries.contains_key(&image_file_name) {
+            collisions
+                .entry(image_file_name)
+                .or_default()
+                .push(relative_path);
+            continue;
+        }
+
         let hash = compute_sha256_hash(&image.path)?;
         let file = runtime
             .block_on(tokio::fs::File::open(&image.path))
@@ -353,33 +370,40 @@ fn upload_images(
                 .expiration_policy(expiration),
         );
 
-        let image_file_name = image
-            .relative_path
-            .file_name()
-            .unwrap_or_default()
-            .to_string_lossy()
-            .into_owned();
-
-        let extra = read_sidecar_metadata(&image.path).unwrap_or_else(|err| {
+        let mut extra = read_sidecar_metadata(&image.path).unwrap_or_else(|err| {
             warn!("Error reading sidecar metadata, ignoring it instead: {err:#}");
             HashMap::new()
         });
+        extra.insert("content_hash".to_owned(), serde_json::Value::String(hash));
 
+        kept_paths.insert(image_file_name.clone(), relative_path);
         manifest_entries.insert(
-            hash,
-            ImageMetadata::new(image_file_name, image.width, image.height, extra),
+            image_file_name,
+            ImageMetadata::new(image.width, image.height, extra),
         );
     }
 
+    if !collisions.is_empty() {
+        let mut details = String::new();
+        for (name, excluded_paths) in &collisions {
+            let mut all_paths = vec![kept_paths[name].as_str()];
+            all_paths.extend(excluded_paths.iter().map(|s| s.as_str()));
+            details.push_str(&format!("\n  {name}: {}", all_paths.join(", ")));
+        }
+        warn!("Some images share identical file names. Only the first occurrence of each is included:{details}");
+    }
+
     let result = runtime.block_on(async { many_builder.send().error_for_failures().await });
 
+    let uploaded_count = manifest_entries.len();
+
     match result {
         Ok(()) => {
             println!(
                 "{} Uploaded {} image {}",
                 style(">").dim(),
-                style(image_count).yellow(),
-                if image_count == 1 { "file" } else { "files" }
+                style(uploaded_count).yellow(),
+                if uploaded_count == 1 { "file" } else { "files" }
             );
             Ok(manifest_entries)
         }
@@ -391,7 +415,7 @@ fn upload_images(
                 eprintln!("  {}", style(format!("{error:#}")).red());
                 error_count += 1;
             }
-            anyhow::bail!("Failed to upload {error_count} out of {image_count} images")
+            anyhow::bail!("Failed to upload {error_count} out of {uploaded_count} images")
         }
     }
 }

{sentry_cli-3.3.3 → sentry_cli-3.3.4}/src/commands/build/upload.rs

@@ -143,6 +143,20 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
             return Err(anyhow!("Path does not exist: {}", path.display()));
         }
 
+        // On non-Apple Silicon, reject xcarchive/IPA early before trying to
+        // open the path as a file (xcarchive is a directory, so ByteView::open
+        // would fail with a confusing I/O error).
+        #[cfg(not(all(target_os = "macos", target_arch = "aarch64")))]
+        {
+            let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+            if ext.eq_ignore_ascii_case("xcarchive") || ext.eq_ignore_ascii_case("ipa") {
+                return Err(anyhow!(
+                    "Uploading XCArchive and IPA files requires an Apple Silicon Mac: {}",
+                    path.display()
+                ));
+            }
+        }
+
         let byteview = ByteView::open(path)?;
         debug!("Loaded file with {} bytes", byteview.len());
 
@@ -301,6 +315,7 @@ fn validate_is_supported_build(path: &Path, bytes: &[u8]) -> Result<()> {
     }
 
     debug!("File format validation failed");
+
     #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
     let format_list = "APK, AAB, XCArchive, or IPA";
     #[cfg(not(all(target_os = "macos", target_arch = "aarch64")))]

sentry_cli-3.3.4/src/commands/code_mappings/mod.rs

@@ -0,0 +1,45 @@
+use anyhow::Result;
+use clap::{ArgMatches, Command};
+
+use crate::utils::args::ArgExt as _;
+
+pub mod upload;
+
+macro_rules! each_subcommand {
+    ($mac:ident) => {
+        $mac!(upload);
+    };
+}
+
+pub fn make_command(mut command: Command) -> Command {
+    macro_rules! add_subcommand {
+        ($name:ident) => {{
+            command = command.subcommand(crate::commands::code_mappings::$name::make_command(
+                Command::new(stringify!($name).replace('_', "-")),
+            ));
+        }};
+    }
+
+    command = command
+        .about("Manage code mappings for Sentry. Code mappings link stack trace paths to source code paths in your repository, enabling source context and code linking in Sentry.")
+        .subcommand_required(true)
+        .arg_required_else_help(true)
+        .org_arg()
+        .project_arg(false);
+    each_subcommand!(add_subcommand);
+    command
+}
+
+pub fn execute(matches: &ArgMatches) -> Result<()> {
+    macro_rules! execute_subcommand {
+        ($name:ident) => {{
+            if let Some(sub_matches) =
+                matches.subcommand_matches(&stringify!($name).replace('_', "-"))
+            {
+                return crate::commands::code_mappings::$name::execute(&sub_matches);
+            }
+        }};
+    }
+    each_subcommand!(execute_subcommand);
+    unreachable!();
+}