Add asset catalog files to zip without adding to folder

Author: noahsmartin

apple-catalog-parsing/native/swift/AssetCatalogParser/Sources/AssetCatalogParser/AssetCatalogReader.swift

@@ -7,13 +7,14 @@ import ObjcSupport
 @_cdecl("swift_inspect_asset_catalog")
 // Insepects the asset catalog and writes the results to a JSON file
 // in the xcarchive containing the asset catalog.
-public func swift_inspect_asset_catalog(_ path: UnsafePointer<CChar>) {
+public func swift_inspect_asset_catalog(_ path: UnsafePointer<CChar>, outputPath: UnsafePointer<CChar>) {
     let pathString = String(cString: path)
+    let outputPathString = String(cString: outputPath)
     if #available(macOS 13.0, *) {
         let supportedVersions = [13, 14, 15]
         let version = ProcessInfo.processInfo.operatingSystemVersion
         if supportedVersions.contains(version.majorVersion) {
-            AssetUtil.disect(file: URL(filePath: pathString))
+            AssetUtil.disect(file: URL(filePath: pathString), outputURL: URL(filePath: outputPathString))
         } else {
             print("Skipping asset catalog inspection on unsupported macOS version \(version)")
         }
@@ -48,8 +49,8 @@ typealias objectiveCMethodImp = @convention(c) (AnyObject, Selector, UnsafeRawPo
 >?
 
 enum AssetUtil {
-    private static func createResultsPath(assetPath: URL) throws -> URL {
-        var archiveURL = assetPath
+    private static func createResultsPath(assetURL: URL, outputURL: URL) throws -> URL {
+        var archiveURL = assetURL
         var tailComponents: [String] = []
         while archiveURL.pathExtension != "xcarchive" && archiveURL.pathComponents.count > 1 {
             tailComponents.insert(archiveURL.lastPathComponent, at: 0)
@@ -58,19 +59,18 @@ enum AssetUtil {
         if archiveURL.pathExtension != "xcarchive" {
             throw Error.pathError
         }
-        let parsedRoot = archiveURL.appendingPathComponent("ParsedAssets",
-                                                           isDirectory: true)
+
         let destDir = tailComponents
             .dropLast()
-            .reduce(parsedRoot) { partial, next in
+            .reduce(outputURL) { partial, next in
                 partial.appendingPathComponent(next, isDirectory: true)
             }
         try! FileManager.default.createDirectory(at: destDir,
                                                  withIntermediateDirectories: true)
         return destDir
     }
 
-    @discardableResult static func disect(file: URL) -> [AssetCatalogEntry] {
+    @discardableResult static func disect(file: URL, outputURL: URL) -> [AssetCatalogEntry] {
         var assets: [AssetCatalogEntry] = []
         var colorLength: UInt = 0
         var colorCount = 0
@@ -154,7 +154,7 @@ enum AssetUtil {
         ))
 
         let data = try! JSONEncoder().encode(assets)
-        let folder = try! createResultsPath(assetPath: file)
+        let folder = try! createResultsPath(assetURL: file, outputURL: outputURL)
         let url = folder
             .appendingPathComponent("Assets")
             .appendingPathExtension("json")

apple-catalog-parsing/native/swift/AssetCatalogParser/Tests/AssetCatalogParserTests/AssetCatalogParserTests.swift

@@ -6,7 +6,7 @@ struct AssetCatalogParserTests {
   @Test func testParseAssets() throws {
     let archivePath = try #require(Bundle.module.path(forResource: "test", ofType: "xcarchive"))
     let url = URL(filePath: "\(archivePath)/Products/Applications/DemoApp.app/Assets.car")
-    let results = AssetUtil.disect(file: url)
+    let results = AssetUtil.disect(file: url, outputURL: URL(filePath: "\(archivePath)/ParsedAssets"))
     #expect(results.count == 2)
   }
 }

apple-catalog-parsing/src/asset_catalog.rs

@@ -11,7 +11,10 @@ pub enum Error {
 }
 
 extern "C" {
-    fn swift_inspect_asset_catalog(msg: *const std::os::raw::c_char);
+    fn swift_inspect_asset_catalog(
+        catalog_path: *const std::os::raw::c_char,
+        output_path: *const std::os::raw::c_char,
+    );
 }
 
 /// This calls out to Swift code that uses Apple APIs to convert the contents
@@ -20,17 +23,19 @@ extern "C" {
 /// as duplicate image detection, xray, and image optimization insights.
 /// The path should be in an xcarchive file, results are written
 /// to a JSON file in the xcarchive’s ParsedAssets directory.
-pub fn inspect_asset_catalog<P>(path: P) -> Result<(), Error>
+pub fn inspect_asset_catalog<P>(catalog_path: P, output_path: P) -> Result<(), Error>
 where
     P: AsRef<Path>,
 {
-    let c_string = CString::new(path.as_ref().as_os_str().as_bytes())?;
-    let string_ptr = c_string.as_ptr();
+    let catalog_c_string = CString::new(catalog_path.as_ref().as_os_str().as_bytes())?;
+    let output_path_c_string = CString::new(output_path.as_ref().as_os_str().as_bytes())?;
+    let catalog_string_ptr = catalog_c_string.as_ptr();
+    let output_string_ptr = output_path_c_string.as_ptr();
     unsafe {
         // The string pointed to is immutable, in Swift we cannot change it.
         // We ensure this by using "UnsafePointer<CChar>" in Swift which is
         // immutable (as opposed to "UnsafeMutablePointer<CChar>").
-        swift_inspect_asset_catalog(string_ptr);
+        swift_inspect_asset_catalog(catalog_string_ptr, output_string_ptr);
     }
     Ok(())
 }

src/commands/mobile_app/upload.rs

@@ -4,7 +4,7 @@ use std::fs;
 use std::io::Write as _;
 #[cfg(not(windows))]
 use std::os::unix::fs::PermissionsExt as _;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use anyhow::{anyhow, bail, Context as _, Result};
 use clap::{Arg, ArgAction, ArgMatches, Command};
@@ -13,6 +13,7 @@ use itertools::Itertools as _;
 use log::{debug, info, warn};
 use sha1_smol::Digest;
 use symbolic::common::ByteView;
+use walkdir::WalkDir;
 use zip::write::SimpleFileOptions;
 use zip::{DateTime, ZipWriter};
 
@@ -21,7 +22,6 @@ use crate::config::Config;
 use crate::utils::args::ArgExt as _;
 use crate::utils::chunks::{upload_chunks, Chunk, ASSEMBLE_POLL_INTERVAL};
 use crate::utils::fs::get_sha1_checksums;
-#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
 use crate::utils::fs::TempDir;
 use crate::utils::fs::TempFile;
 #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
@@ -95,19 +95,14 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
         let byteview = ByteView::open(path)?;
         debug!("Loaded file with {} bytes", byteview.len());
 
-        #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
-        if is_apple_app(path) {
-            handle_asset_catalogs(path);
-        }
-
         validate_is_mobile_app(path, &byteview)?;
 
         let normalized_zip = if path.is_file() {
             debug!("Normalizing file: {}", path.display());
             handle_file(path, &byteview)?
         } else if path.is_dir() {
             debug!("Normalizing directory: {}", path.display());
-            normalize_directory(path).with_context(|| {
+            handle_directory(path).with_context(|| {
                 format!(
                     "Failed to generate uploadable bundle for directory {}",
                     path.display()
@@ -187,9 +182,9 @@ fn handle_file(path: &Path, byteview: &ByteView) -> Result<TempFile> {
     #[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 temp_dir = TempDir::create()?;
-        return ipa_to_xcarchive(path, byteview, &temp_dir)
-            .and_then(|path| normalize_directory(&path))
+        let archive_temp_dir = TempDir::create()?;
+        return ipa_to_xcarchive(path, byteview, &archive_temp_dir)
+            .and_then(|path| handle_directory(&path))
             .with_context(|| format!("Failed to process IPA file {}", path.display()));
     }
 
@@ -276,38 +271,45 @@ fn normalize_file(path: &Path, bytes: &[u8]) -> Result<TempFile> {
     Ok(temp_file)
 }
 
+fn sort_entries(path: &Path) -> Result<std::vec::IntoIter<(PathBuf, PathBuf)>> {
+    Ok(WalkDir::new(path)
+        .follow_links(true)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|entry| entry.path().is_file())
+        .map(|entry| {
+            let entry_path = entry.into_path();
+            let relative_path = entry_path.strip_prefix(path)?.to_owned();
+            Ok((entry_path, relative_path))
+        })
+        .collect::<Result<Vec<_>>>()?
+        .into_iter()
+        .sorted_by(|(_, a), (_, b)| a.cmp(b)))
+}
+
+fn handle_directory(path: &Path) -> 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())
+}
+
 // For XCArchive directories, we'll zip the entire directory
-fn normalize_directory(path: &Path) -> Result<TempFile> {
+fn normalize_directory(path: &Path, parsed_assets_path: &Path) -> Result<TempFile> {
     debug!("Creating normalized zip for directory: {}", path.display());
 
     let temp_file = TempFile::create()?;
     let mut zip = ZipWriter::new(temp_file.open()?);
 
     let mut file_count = 0;
+    let directory_name = path.file_name().expect("Failed to get basename");
 
     // Collect and sort entries for deterministic ordering
     // This is important to ensure stable sha1 checksums for the zip file as
     // an optimization is used to avoid re-uploading the same chunks if they're already on the server.
-    let entries = walkdir::WalkDir::new(path)
-        .follow_links(true)
-        .into_iter()
-        .filter_map(Result::ok)
-        .filter(|entry| entry.path().is_file())
-        .map(|entry| {
-            let entry_path = entry.into_path();
-            let relative_path = entry_path
-                .strip_prefix(path.parent().ok_or_else(|| {
-                    anyhow!(
-                        "Cannot determine parent directory for path: {}",
-                        path.display()
-                    )
-                })?)?
-                .to_owned();
-            Ok((entry_path, relative_path))
-        })
-        .collect::<Result<Vec<_>>>()?
-        .into_iter()
-        .sorted_by(|(_, a), (_, b)| a.cmp(b));
+    let entries = sort_entries(path)?;
 
     // Need to set the last modified time to a fixed value to ensure consistent checksums
     // This is important as an optimization to avoid re-uploading the same chunks if they're already on the server
@@ -317,18 +319,47 @@ fn normalize_directory(path: &Path) -> Result<TempFile> {
         .last_modified_time(DateTime::default());
 
     for (entry_path, relative_path) in entries {
-        debug!("Adding file to zip: {}", relative_path.display());
+        let zip_path = format!(
+            "{}/{}",
+            directory_name.to_string_lossy(),
+            relative_path.to_string_lossy()
+        );
+        debug!("Adding file to zip: {}", zip_path);
 
         #[cfg(not(windows))]
         // On Unix, we need to preserve the file permissions.
         let options = options.unix_permissions(fs::metadata(&entry_path)?.permissions().mode());
 
-        zip.start_file(relative_path.to_string_lossy(), options)?;
+        zip.start_file(zip_path, options)?;
         let file_byteview = ByteView::open(&entry_path)?;
         zip.write_all(file_byteview.as_slice())?;
         file_count += 1;
     }
 
+    // Add parsed assets to the zip in a "ParsedAssets" directory
+    if parsed_assets_path.exists() {
+        debug!(
+            "Adding parsed assets from: {}",
+            parsed_assets_path.display()
+        );
+
+        let parsed_assets_entries = sort_entries(parsed_assets_path)?;
+
+        for (entry_path, relative_path) in parsed_assets_entries {
+            let zip_path = format!(
+                "{}/ParsedAssets/{}",
+                directory_name.to_string_lossy(),
+                relative_path.to_string_lossy()
+            );
+            debug!("Adding parsed asset to zip: {}", zip_path);
+
+            zip.start_file(zip_path, options)?;
+            let file_byteview = ByteView::open(&entry_path)?;
+            zip.write_all(file_byteview.as_slice())?;
+            file_count += 1;
+        }
+    }
+
     zip.finish()?;
     debug!(
         "Successfully created normalized zip for directory with {} files",
@@ -470,12 +501,66 @@ 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)?;
+        let result_zip = normalize_directory(&test_dir, temp_dir.path())?;
         let zip_file = fs::File::open(result_zip.path())?;
         let mut archive = ZipArchive::new(zip_file)?;
         let file = archive.by_index(0)?;
         let file_path = file.name();
         assert_eq!(file_path, "MyApp.xcarchive/Products/app.txt");
         Ok(())
     }
+
+    #[test]
+    #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+    fn test_xcarchive_upload_includes_parsed_assets() -> Result<()> {
+        // Test that XCArchive uploads include parsed asset catalogs
+        let xcarchive_path = Path::new("tests/integration/_fixtures/mobile_app/archive.xcarchive");
+        
+        // Process the XCArchive directory
+        let result = handle_directory(xcarchive_path)?;
+        
+        // Verify the resulting zip contains parsed assets
+        let zip_file = fs::File::open(result.path())?;
+        let mut archive = ZipArchive::new(zip_file)?;
+        
+        let mut has_parsed_assets = false;
+        for i in 0..archive.len() {
+            let file = archive.by_index(i)?;
+            let file_name = file.enclosed_name().ok_or(anyhow!("Failed to get file name"))?;
+            if file_name.to_string_lossy().contains("ParsedAssets") {
+                has_parsed_assets = true;
+                break;
+            }
+        }
+        
+        assert!(has_parsed_assets, "XCArchive upload should include parsed asset catalogs");
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+    fn test_ipa_upload_includes_parsed_assets() -> Result<()> {
+        // Test that IPA uploads handle missing asset catalogs gracefully
+        let ipa_path = Path::new("tests/integration/_fixtures/mobile_app/ipa_with_asset.ipa");
+        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 zip_file = fs::File::open(result.path())?;
+        let mut archive = ZipArchive::new(zip_file)?;
+        
+        let mut has_parsed_assets = false;
+        for i in 0..archive.len() {
+            let file = archive.by_index(i)?;
+            let file_name = file.enclosed_name().ok_or(anyhow!("Failed to get file name"))?;
+            if file_name.to_string_lossy().contains("ParsedAssets") {
+                has_parsed_assets = true;
+                break;
+            }
+        }
+        
+        assert!(has_parsed_assets, "XCArchive upload should include parsed asset catalogs");
+        Ok(())
+    }
 }

src/utils/mobile_app/apple.rs

@@ -12,11 +12,13 @@ use std::io::Cursor;
 use walkdir::WalkDir;
 use zip::ZipArchive;
 
-pub fn handle_asset_catalogs(path: &Path) {
+pub fn handle_asset_catalogs(archive_path: &Path, output_path: &Path) {
     // Find all asset catalogs
-    let cars = find_car_files(path);
+    let cars = find_car_files(archive_path);
     for car in &cars {
-        if let Err(e) = apple_catalog_parsing::inspect_asset_catalog(car) {
+        if let Err(e) =
+            apple_catalog_parsing::inspect_asset_catalog(car, &output_path.to_path_buf())
+        {
             eprintln!("Failed to inspect asset catalog {}: {e}", car.display());
         }
     }

tests/integration/_cases/mobile_app/mobile_app-upload-xcarchive-all-uploaded.trycmd

@@ -0,0 +1,9 @@
+```
+$ sentry-cli mobile-app upload tests/integration/_fixtures/mobile_app/archive.xcarchive
+? success
+[..]WARN[..]EXPERIMENTAL: The mobile-app subcommand is experimental. The command is subject to breaking changes and may be removed without notice in any release.
+Nothing to upload, all files are on the server
+Successfully uploaded 1 file to Sentry
+  - tests/integration/_fixtures/mobile_app/archive.xcarchive
+
+```