sentry-cli 2.58.0__tar.gz → 2.58.2__tar.gz

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/Cargo.lock

@@ -2726,7 +2726,7 @@ dependencies = [
 
 [[package]]
 name = "sentry-cli"
-version = "2.58.0"
+version = "2.58.2"
 dependencies = [
  "anyhow",
  "anylog",

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/Cargo.toml

@@ -1,8 +1,7 @@
 [package]
-authors = ["Armin Ronacher <armin.ronacher@active-4.com>"]
 build = "build.rs"
 name = "sentry-cli"
-version = "2.58.0"
+version = "2.58.2"
 edition = "2021"
 rust-version = "1.86"
 
@@ -63,7 +62,7 @@ sentry = { version = "0.34.0", default-features = false, features = [
 ] }
 serde = { version = "1.0.152", features = ["derive"] }
 serde_json = "1.0.93"
-sha1_smol = { version = "1.0.0", features = ["serde"] }
+sha1_smol = { version = "1.0.0", features = ["serde", "std"] }
 sourcemap = { version = "9.2.0", features = ["ram_bundle"] }
 symbolic = { version = "12.13.3", features = ["debuginfo-serde", "il2cpp"] }
 thiserror = "1.0.38"
@@ -99,8 +98,8 @@ with_crash_reporting = []
 allow-attributes = "warn"
 dbg-macro = "warn"
 elidable-lifetime-names = "warn"
+implicit-clone = "warn"
 str-to-string = "warn"
-string-to-string = "warn"
 tests-outside-test-module = "warn"
 unnecessary-wraps = "warn"
 uninlined-format-args = "warn"

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/PKG-INFO

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

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/apple-catalog-parsing/native/swift/AssetCatalogParser/Sources/AssetCatalogParser/AssetCatalogReader.swift

@@ -11,7 +11,7 @@ public func swift_inspect_asset_catalog(_ path: UnsafePointer<CChar>, outputPath
     let pathString = String(cString: path)
     let outputPathString = String(cString: outputPath)
     if #available(macOS 13.0, *) {
-        let supportedVersions = [13, 14, 15]
+        let supportedVersions = [13, 14, 15, 26]
         let version = ProcessInfo.processInfo.operatingSystemVersion
         if supportedVersions.contains(version.majorVersion) {
             AssetUtil.disect(file: URL(filePath: pathString), outputURL: URL(filePath: outputPathString))

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/sentry_cli.egg-info/PKG-INFO

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

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/sentry_cli.egg-info/SOURCES.txt

@@ -137,6 +137,7 @@ src/utils/non_empty.rs
 src/utils/progress.rs
 src/utils/releases.rs
 src/utils/retry.rs
+src/utils/source_bundle.rs
 src/utils/sourcemaps.rs
 src/utils/system.rs
 src/utils/ui.rs

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/src/api/data_types/chunking/build.rs

@@ -11,23 +11,8 @@ pub struct ChunkedBuildRequest<'a> {
     pub build_configuration: Option<&'a str>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub release_notes: Option<&'a str>,
-    // VCS fields
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub head_sha: Option<&'a str>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub base_sha: Option<&'a str>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub provider: Option<&'a str>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub head_repo_name: Option<&'a str>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub base_repo_name: Option<&'a str>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub head_ref: Option<&'a str>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub base_ref: Option<&'a str>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub pr_number: Option<&'a u32>,
+    #[serde(flatten)]
+    pub vcs_info: &'a VcsInfo<'a>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -38,3 +23,24 @@ pub struct AssembleBuildResponse {
     pub detail: Option<String>,
     pub artifact_url: Option<String>,
 }
+
+/// VCS information for build app uploads
+#[derive(Debug, Serialize)]
+pub struct VcsInfo<'a> {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub head_sha: Option<Digest>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub base_sha: Option<Digest>,
+    #[serde(skip_serializing_if = "str::is_empty", rename = "provider")]
+    pub vcs_provider: &'a str,
+    #[serde(skip_serializing_if = "str::is_empty")]
+    pub head_repo_name: &'a str,
+    #[serde(skip_serializing_if = "str::is_empty")]
+    pub base_repo_name: &'a str,
+    #[serde(skip_serializing_if = "str::is_empty")]
+    pub head_ref: &'a str,
+    #[serde(skip_serializing_if = "str::is_empty")]
+    pub base_ref: &'a str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pr_number: Option<&'a u32>,
+}

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/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};
+pub use self::build::{AssembleBuildResponse, ChunkedBuildRequest, VcsInfo};
 pub use self::compression::ChunkCompression;
 pub use self::dif::{AssembleDifsRequest, AssembleDifsResponse, ChunkedDifRequest};
 pub use self::file_state::ChunkedFileState;

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/src/api/mod.rs

@@ -1411,6 +1411,7 @@ impl<'a> AuthenticatedApi<'a> {
                     region_url.ok().map(|url| url.into())
                 }
             },
+            #[expect(deprecated, reason = "Auth key is deprecated.")]
             Auth::Key(_) => {
                 log::warn!(
                     "Auth key is not supported for region-specific API. Falling back to default region."
@@ -1771,9 +1772,10 @@ impl ApiRequest {
     pub fn with_auth(mut self, auth: &Auth) -> ApiResult<Self> {
         self.is_authenticated = true;
         match *auth {
+            #[expect(deprecated, reason = "API key is deprecated.")]
             Auth::Key(ref key) => {
                 self.handle.username(key)?;
-                debug!("using key based authentication");
+                debug!("using deprecated key based authentication");
                 Ok(self)
             }
             Auth::Token(ref token) => {
@@ -2518,19 +2520,6 @@ struct LogsResponse {
     data: Vec<LogEntry>,
 }
 
-/// VCS information for build app uploads
-#[derive(Debug)]
-pub struct VcsInfo<'a> {
-    pub head_sha: Option<&'a str>,
-    pub base_sha: Option<&'a str>,
-    pub vcs_provider: Option<&'a str>,
-    pub head_repo_name: Option<&'a str>,
-    pub base_repo_name: Option<&'a str>,
-    pub head_ref: Option<&'a str>,
-    pub base_ref: Option<&'a str>,
-    pub pr_number: Option<&'a u32>,
-}
-
 /// Log entry structure from the logs API
 #[derive(Debug, Deserialize, Clone)]
 pub struct LogEntry {

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/src/commands/build/upload.rs

@@ -6,6 +6,7 @@ use anyhow::{anyhow, bail, Context as _, Result};
 use clap::{Arg, ArgAction, ArgMatches, Command};
 use indicatif::ProgressStyle;
 use log::{debug, info, warn};
+use sha1_smol::Digest;
 use symbolic::common::ByteView;
 use zip::write::SimpleFileOptions;
 use zip::{DateTime, ZipWriter};
@@ -53,11 +54,13 @@ pub fn make_command(command: Command) -> Command {
         .arg(
             Arg::new("head_sha")
                 .long("head-sha")
+                .value_parser(parse_sha_allow_empty)
                 .help("The VCS commit sha to use for the upload. If not provided, the current commit sha will be used.")
         )
         .arg(
             Arg::new("base_sha")
                 .long("base-sha")
+                .value_parser(parse_sha_allow_empty)
                 .help("The VCS commit's base sha to use for the upload. If not provided, the merge-base of the current and remote branch will be used.")
         )
         .arg(
@@ -112,10 +115,10 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
         .expect("paths argument is required");
 
     let head_sha = matches
-        .get_one("head_sha")
-        .map(String::as_str)
-        .map(Cow::Borrowed)
-        .or_else(|| vcs::find_head_sha().ok().map(Cow::Owned));
+        .get_one::<Option<Digest>>("head_sha")
+        .map(|d| d.as_ref().cloned())
+        .or_else(|| Some(vcs::find_head_sha().ok()))
+        .flatten();
 
     let cached_remote = config.get_cached_vcs_remote();
     // Try to open the git repository and find the remote, but handle errors gracefully.
@@ -134,7 +137,8 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
                     .as_ref()
                     .map(|url| get_provider_from_remote(url))
                     .map(Cow::Owned)
-            });
+            })
+            .unwrap_or_default();
 
         let head_repo_name = matches
             .get_one("head_repo_name")
@@ -145,7 +149,8 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
                     .as_ref()
                     .map(|url| get_repo_from_remote_preserve_case(url))
                     .map(Cow::Owned)
-            });
+            })
+            .unwrap_or_default();
 
         let head_ref = matches
             .get_one("head_ref")
@@ -172,7 +177,8 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
                         }
                     })
                     .map(Cow::Owned)
-            });
+            })
+            .unwrap_or_default();
 
         let base_ref = matches
             .get_one("base_ref")
@@ -196,7 +202,8 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
                         }
                     })
                     .map(Cow::Owned)
-            });
+            })
+            .unwrap_or_default();
 
         let base_repo_name = matches
             .get_one("base_repo_name")
@@ -220,7 +227,8 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
                         }
                     })
                     .map(Cow::Owned)
-            });
+            })
+            .unwrap_or_default();
 
         (
             vcs_provider,
@@ -230,17 +238,41 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
             base_repo_name,
         )
     };
-    let base_sha = matches
-        .get_one("base_sha")
-        .map(String::as_str)
-        .map(Cow::Borrowed)
+
+    // Track whether base_sha and base_ref were explicitly provided by the user
+    let base_sha_from_user = matches.get_one::<Option<Digest>>("base_sha").is_some();
+    let base_ref_from_user = matches.get_one::<String>("base_ref").is_some();
+
+    let mut base_sha = matches
+        .get_one::<Option<Digest>>("base_sha")
+        .map(|d| d.as_ref().cloned())
         .or_else(|| {
-            vcs::find_base_sha(&cached_remote)
-                .inspect_err(|e| debug!("Error finding base SHA: {e}"))
-                .ok()
-                .flatten()
-                .map(Cow::Owned)
-        });
+            Some(
+                vcs::find_base_sha(&cached_remote)
+                    .inspect_err(|e| debug!("Error finding base SHA: {e}"))
+                    .ok()
+                    .flatten(),
+            )
+        })
+        .flatten();
+
+    let mut base_ref = base_ref;
+
+    // If base_sha equals head_sha and both were auto-inferred, skip setting base_sha and base_ref
+    // but keep head_sha (since comparing a commit to itself provides no meaningful baseline)
+    if !base_sha_from_user
+        && !base_ref_from_user
+        && base_sha.is_some()
+        && head_sha.is_some()
+        && base_sha == head_sha
+    {
+        debug!(
+            "Base SHA equals head SHA ({}), and both were auto-inferred. Skipping base_sha and base_ref, but keeping head_sha.",
+            base_sha.expect("base_sha is Some at this point")
+        );
+        base_sha = None;
+        base_ref = "".into();
+    }
     let pr_number = matches
         .get_one("pr_number")
         .copied()
@@ -302,13 +334,13 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
         info!("Uploading file: {}", path.display());
         let bytes = ByteView::open(zip.path())?;
         let vcs_info = VcsInfo {
-            head_sha: head_sha.as_deref(),
-            base_sha: base_sha.as_deref(),
-            vcs_provider: vcs_provider.as_deref(),
-            head_repo_name: head_repo_name.as_deref(),
-            base_repo_name: base_repo_name.as_deref(),
-            head_ref: head_ref.as_deref(),
-            base_ref: base_ref.as_deref(),
+            head_sha,
+            base_sha,
+            vcs_provider: &vcs_provider,
+            head_repo_name: &head_repo_name,
+            base_repo_name: &base_repo_name,
+            head_ref: &head_ref,
+            base_ref: &base_ref,
             pr_number: pr_number.as_ref(),
         };
         match upload_file(
@@ -543,14 +575,7 @@ fn upload_file(
                 chunks: &checksums,
                 build_configuration,
                 release_notes,
-                head_sha: vcs_info.head_sha,
-                base_sha: vcs_info.base_sha,
-                provider: vcs_info.vcs_provider,
-                head_repo_name: vcs_info.head_repo_name,
-                base_repo_name: vcs_info.base_repo_name,
-                head_ref: vcs_info.head_ref,
-                base_ref: vcs_info.base_ref,
-                pr_number: vcs_info.pr_number,
+                vcs_info,
             },
         )?;
         chunks.retain(|Chunk((digest, _))| response.missing_chunks.contains(digest));
@@ -582,6 +607,22 @@ fn upload_file(
     result
 }
 
+/// Utility function to parse a SHA1 digest, allowing empty strings.
+///
+/// Empty strings result in Ok(None), otherwise we return the parsed digest
+/// or an error if the SHA is invalid.
+fn parse_sha_allow_empty(sha: &str) -> Result<Option<Digest>> {
+    if sha.is_empty() {
+        return Ok(None);
+    }
+
+    let digest = sha
+        .parse()
+        .with_context(|| format!("{sha} is not a valid SHA1 digest"))?;
+
+    Ok(Some(digest))
+}
+
 #[cfg(not(windows))]
 #[cfg(test)]
 mod tests {

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/src/commands/debug_files/bundle_jvm.rs

@@ -1,12 +1,11 @@
 #![expect(clippy::unwrap_used, reason = "contains legacy code which uses unwrap")]
 
-use crate::api::Api;
 use crate::config::Config;
-use crate::constants::DEFAULT_MAX_WAIT;
 use crate::utils::args::ArgExt as _;
 use crate::utils::file_search::ReleaseFileSearch;
-use crate::utils::file_upload::{FileUpload, SourceFile, UploadContext};
+use crate::utils::file_upload::SourceFile;
 use crate::utils::fs::path_as_url;
+use crate::utils::source_bundle::{self, BundleContext};
 use anyhow::{bail, Context as _, Result};
 use clap::{Arg, ArgMatches, Command};
 use sentry::types::DebugId;
@@ -54,19 +53,8 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
     let config = Config::current();
     let org = config.get_org(matches)?;
     let project = config.get_project(matches).ok();
-    let api = Api::current();
-    let chunk_upload_options = api.authenticated()?.get_chunk_upload_options(&org)?;
 
-    let context = &UploadContext {
-        org: &org,
-        projects: project.as_slice().try_into().ok(),
-        release: None,
-        dist: None,
-        note: None,
-        wait: true,
-        max_wait: DEFAULT_MAX_WAIT,
-        chunk_upload_options: chunk_upload_options.as_ref(),
-    };
+    let context = BundleContext::new(&org).with_projects(project.as_slice());
     let path = matches.get_one::<PathBuf>("path").unwrap();
     let output_path = matches.get_one::<PathBuf>("output").unwrap();
     let debug_id = matches.get_one::<DebugId>("debug_id").unwrap();
@@ -87,31 +75,24 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
         ))?;
     }
 
-    let sources = ReleaseFileSearch::new(path.to_path_buf()).collect_files()?;
-    let files = sources
-        .iter()
-        .map(|source| {
-            let local_path = source.path.strip_prefix(&source.base_path).unwrap();
-            let local_path_jvm_ext = local_path.with_extension("jvm");
-            let url = format!("~/{}", path_as_url(&local_path_jvm_ext));
-            (
-                url.clone(),
-                SourceFile {
-                    url,
-                    path: source.path.clone(),
-                    contents: Arc::new(source.contents.clone()),
-                    ty: SourceFileType::Source,
-                    headers: BTreeMap::new(),
-                    messages: vec![],
-                    already_uploaded: false,
-                },
-            )
-        })
-        .collect();
+    let sources = ReleaseFileSearch::new(path.clone()).collect_files()?;
+    let files = sources.iter().map(|source| {
+        let local_path = source.path.strip_prefix(&source.base_path).unwrap();
+        let local_path_jvm_ext = local_path.with_extension("jvm");
+        let url = format!("~/{}", path_as_url(&local_path_jvm_ext));
 
-    let tempfile = FileUpload::new(context)
-        .files(&files)
-        .build_jvm_bundle(Some(*debug_id))
+        SourceFile {
+            url,
+            path: source.path.clone(),
+            contents: Arc::new(source.contents.clone()),
+            ty: SourceFileType::Source,
+            headers: BTreeMap::new(),
+            messages: vec![],
+            already_uploaded: false,
+        }
+    });
+
+    let tempfile = source_bundle::build(context, files, Some(*debug_id))
         .context("Unable to create source bundle")?;
 
     fs::copy(tempfile.path(), &out).context("Unable to write source bundle")?;

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/src/commands/debug_files/find.rs

@@ -324,7 +324,7 @@ where
 {
     ids.filter_map(|id| {
         if remaining.contains(&id) {
-            return Some((id.to_owned(), t));
+            return Some((id, t));
         }
         None
     })

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/src/commands/info.rs

@@ -59,7 +59,8 @@ fn describe_auth(auth: Option<&Auth>) -> &str {
     match auth {
         None => "Unauthorized",
         Some(&Auth::Token(_)) => "Auth Token",
-        Some(&Auth::Key(_)) => "API Key",
+        #[expect(deprecated, reason = "API key is deprecated.")]
+        Some(&Auth::Key(_)) => "API Key (deprecated)",
     }
 }
 
@@ -74,6 +75,7 @@ fn get_config_status_json() -> Result<()> {
 
     rv.auth.auth_type = config.get_auth().map(|val| match val {
         Auth::Token(_) => "token".into(),
+        #[expect(deprecated, reason = "API key is deprecated.")]
         Auth::Key(_) => "api_key".into(),
     });
     rv.auth.successful =

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/src/commands/login.rs

@@ -140,6 +140,7 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
 fn get_org_from_auth(auth: &Auth) -> Option<&str> {
     match auth {
         Auth::Token(token) => get_org_from_token(token),
+        #[expect(deprecated, reason = "API key is deprecated.")]
         Auth::Key(_) => None,
     }
 }

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/src/commands/mod.rs

@@ -138,7 +138,15 @@ fn preexecute_hooks() -> Result<bool> {
 
 fn configure_args(config: &mut Config, matches: &ArgMatches) {
     if let Some(api_key) = matches.get_one::<String>("api_key") {
-        config.set_auth(Auth::Key(api_key.to_owned()));
+        log::warn!(
+            "[DEPRECTATION NOTICE] API key authentication and the --api-key argument are \
+            deprecated. \
+            Please generate an auth token, and use the --auth-token argument instead."
+        );
+
+        #[expect(deprecated, reason = "Auth key is deprecated.")]
+        let auth = Auth::Key(api_key.to_owned());
+        config.set_auth(auth);
     }
 
     if let Some(auth_token) = matches.get_one::<AuthToken>("auth_token") {
@@ -188,7 +196,8 @@ fn app() -> Command {
             Arg::new("api_key")
                 .value_name("API_KEY")
                 .long("api-key")
-                .help("Use the given Sentry API key."),
+                .hide(true)
+                .help("[DEPRECATED] Use the given Sentry API key."),
         )
         .arg(
             Arg::new("log_level")

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/src/commands/upload_proguard.rs

@@ -332,7 +332,7 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
                 &org,
                 &project,
                 &AssociateProguard {
-                    release_name: release_name.to_owned(),
+                    release_name: release_name.clone(),
                     proguard_uuid: uuid.to_string(),
                 },
             )?;

{sentry_cli-2.58.0 → sentry_cli-2.58.2}/src/config.rs

@@ -36,6 +36,7 @@ const MAX_RETRIES_INI_KEY: &str = "max_retries";
 /// Represents the auth information
 #[derive(Debug, Clone)]
 pub enum Auth {
+    #[deprecated(note = "Auth Key authentication is deprecated.")]
     Key(String),
     Token(AuthToken),
 }
@@ -196,6 +197,7 @@ impl Config {
                     val.raw().expose_secret().clone(),
                 );
             }
+            #[expect(deprecated, reason = "API key is deprecated.")]
             Some(Auth::Key(ref val)) => {
                 self.ini.set_to(Some("auth"), "api_key".into(), val.clone());
             }
@@ -734,15 +736,26 @@ impl Clone for Config {
     }
 }
 
-#[expect(clippy::manual_map)]
 fn get_default_auth(ini: &Ini) -> Option<Auth> {
     if let Ok(val) = env::var("SENTRY_AUTH_TOKEN") {
         Some(Auth::Token(val.into()))
     } else if let Ok(val) = env::var("SENTRY_API_KEY") {
+        log::warn!(
+            "[DEPRECTATION NOTICE] API key authentication and the `SENTRY_API_KEY` environment \
+            variable are deprecated. \
+            Please generate and set an auth token using `SENTRY_AUTH_TOKEN` instead."
+        );
+        #[expect(deprecated, reason = "API key is deprecated.")]
         Some(Auth::Key(val))
     } else if let Some(val) = ini.get_from(Some("auth"), "token") {
         Some(Auth::Token(val.into()))
     } else if let Some(val) = ini.get_from(Some("auth"), "api_key") {
+        log::warn!(
+            "[DEPRECTATION NOTICE] API key authentication and the `api_key` field in the \
+            Sentry CLI config file are deprecated. \
+            Please generate and set an auth token instead."
+        );
+        #[expect(deprecated, reason = "API key is deprecated.")]
         Some(Auth::Key(val.to_owned()))
     } else {
         None