feat(cli): support xcworkspace project context

Author: tranhoangpich

src/main.rs

@@ -233,35 +233,33 @@ fn main() -> Result<()> {
     let project_path = if let Some(p) = args.project {
         Some(p)
     } else {
-        // Auto-detect sibling .xcodeproj
-        let mut xcode_proj = None;
+        // Auto-detect sibling .xcworkspace or .xcodeproj
+        let mut workspace = None;
+        let mut project = None;
         if let Some(parent) = app_path.parent() {
             if let Ok(entries) = std::fs::read_dir(parent) {
                 for entry in entries.flatten() {
                     let path = entry.path();
-                    if path.extension().is_some_and(|ext| ext == "xcodeproj") {
-                        xcode_proj = Some(path);
-                        break;
+                    if workspace.is_none()
+                        && path
+                            .extension()
+                            .is_some_and(|ext| ext.eq_ignore_ascii_case("xcworkspace"))
+                    {
+                        workspace = Some(path.clone());
+                    }
+                    if project.is_none() && path.extension().is_some_and(|ext| ext == "xcodeproj") {
+                        project = Some(path);
                     }
                 }
             }
         }
-        xcode_proj
+        workspace.or(project)
     };
 
     if let Some(path) = project_path {
         pb.set_message(format!("Loading Xcode project: {}...", path.display()));
-        match verifyos_cli::parsers::xcode_parser::XcodeProject::from_path(&path) {
-            Ok(proj) => engine.xcode_project = Some(proj),
-            Err(e) => {
-                pb.suspend(|| {
-                    eprintln!(
-                        "Warning: Failed to load Xcode project at {}: {}",
-                        path.display(),
-                        e
-                    );
-                });
-            }
+        if let Some(project) = load_xcode_project(&path) {
+            engine.xcode_project = Some(project);
         }
     }
 
@@ -361,6 +359,63 @@ fn run_scan_for_agent_pack(
     Ok(agent_pack)
 }
 
+fn load_xcode_project(
+    path: &std::path::Path,
+) -> Option<verifyos_cli::parsers::xcode_parser::XcodeProject> {
+    let extension = path.extension().and_then(|ext| ext.to_str()).unwrap_or("");
+    if extension.eq_ignore_ascii_case("xcworkspace") {
+        match verifyos_cli::parsers::xcworkspace_parser::Xcworkspace::from_path(path) {
+            Ok(workspace) => {
+                for project_path in workspace.project_paths {
+                    match verifyos_cli::parsers::xcode_parser::XcodeProject::from_path(
+                        &project_path,
+                    ) {
+                        Ok(project) => return Some(project),
+                        Err(err) => {
+                            eprintln!(
+                                "Warning: Failed to load Xcode project at {}: {}",
+                                project_path.display(),
+                                err
+                            );
+                        }
+                    }
+                }
+                eprintln!(
+                    "Warning: No usable .xcodeproj found in workspace {}",
+                    path.display()
+                );
+                None
+            }
+            Err(err) => {
+                eprintln!(
+                    "Warning: Failed to read Xcode workspace at {}: {}",
+                    path.display(),
+                    err
+                );
+                None
+            }
+        }
+    } else if extension.eq_ignore_ascii_case("xcodeproj") {
+        match verifyos_cli::parsers::xcode_parser::XcodeProject::from_path(path) {
+            Ok(project) => Some(project),
+            Err(err) => {
+                eprintln!(
+                    "Warning: Failed to load Xcode project at {}: {}",
+                    path.display(),
+                    err
+                );
+                None
+            }
+        }
+    } else {
+        eprintln!(
+            "Warning: Unsupported project type at {} (expected .xcodeproj or .xcworkspace)",
+            path.display()
+        );
+        None
+    }
+}
+
 fn render_rule_inventory(output_format: OutputFormat) -> Result<()> {
     let inventory = rule_inventory();
     match output_format {

src/parsers/mod.rs

@@ -4,4 +4,5 @@ pub mod macho_scanner;
 pub mod plist_reader;
 pub mod provisioning_profile;
 pub mod xcode_parser;
+pub mod xcworkspace_parser;
 pub mod zip_extractor;

src/parsers/xcworkspace_parser.rs

@@ -0,0 +1,116 @@
+use miette::Diagnostic;
+use std::path::{Path, PathBuf};
+use thiserror::Error;
+
+#[derive(Debug, Error, Diagnostic)]
+pub enum WorkspaceError {
+    #[error("Failed to read Xcode workspace at {path}")]
+    ReadError { path: String, description: String },
+    #[error("Missing contents.xcworkspacedata in workspace {path}")]
+    MissingContents { path: String },
+}
+
+#[derive(Debug, Clone)]
+pub struct Xcworkspace {
+    pub project_paths: Vec<PathBuf>,
+}
+
+impl Xcworkspace {
+    pub fn from_path(path: impl AsRef<Path>) -> Result<Self, WorkspaceError> {
+        let path = path.as_ref();
+        let contents_path = if path
+            .extension()
+            .is_some_and(|ext| ext.eq_ignore_ascii_case("xcworkspacedata"))
+        {
+            path.to_path_buf()
+        } else {
+            let workspace_root = path;
+            let contents = workspace_root.join("contents.xcworkspacedata");
+            if !contents.exists() {
+                return Err(WorkspaceError::MissingContents {
+                    path: workspace_root.display().to_string(),
+                });
+            }
+            contents
+        };
+
+        let data =
+            std::fs::read_to_string(&contents_path).map_err(|e| WorkspaceError::ReadError {
+                path: contents_path.display().to_string(),
+                description: format!("{e}"),
+            })?;
+
+        let workspace_dir = contents_path
+            .parent()
+            .map(Path::to_path_buf)
+            .unwrap_or_else(|| PathBuf::from("."));
+
+        let mut project_paths = Vec::new();
+        for location in extract_locations(&data) {
+            if let Some(path) = resolve_location(&workspace_dir, &location) {
+                if path.extension().is_some_and(|ext| ext == "xcodeproj") {
+                    project_paths.push(path);
+                }
+            }
+        }
+
+        Ok(Self { project_paths })
+    }
+}
+
+fn extract_locations(data: &str) -> Vec<String> {
+    let mut locations = Vec::new();
+    let needle = "location=\"";
+    let mut start = 0;
+    while let Some(pos) = data[start..].find(needle) {
+        let idx = start + pos + needle.len();
+        if let Some(end) = data[idx..].find('"') {
+            locations.push(data[idx..idx + end].to_string());
+            start = idx + end + 1;
+        } else {
+            break;
+        }
+    }
+    locations
+}
+
+fn resolve_location(workspace_dir: &Path, location: &str) -> Option<PathBuf> {
+    if let Some(rest) = location.strip_prefix("group:") {
+        Some(workspace_dir.join(rest))
+    } else if let Some(rest) = location.strip_prefix("container:") {
+        Some(workspace_dir.join(rest))
+    } else if let Some(rest) = location.strip_prefix("absolute:") {
+        Some(PathBuf::from(rest))
+    } else if location.starts_with('/') {
+        Some(PathBuf::from(location))
+    } else {
+        Some(workspace_dir.join(location))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::tempdir;
+
+    #[test]
+    fn parses_workspace_file_refs() {
+        let dir = tempdir().expect("tempdir");
+        let workspace_dir = dir.path().join("Demo.xcworkspace");
+        fs::create_dir_all(&workspace_dir).expect("workspace dir");
+        let contents = workspace_dir.join("contents.xcworkspacedata");
+        fs::write(
+            &contents,
+            r#"<?xml version="1.0" encoding="UTF-8"?>
+<Workspace version="1.0">
+   <FileRef location="group:Demo.xcodeproj"></FileRef>
+</Workspace>"#,
+        )
+        .expect("write contents");
+
+        let workspace = Xcworkspace::from_path(&workspace_dir).expect("parse workspace");
+        assert_eq!(workspace.project_paths.len(), 1);
+        assert!(workspace.project_paths[0].ends_with("Demo.xcodeproj"));
+    }
+}