Merge branch 'main' into fix/gen-copy-deps

Author: sleitor

Cargo.lock

@@ -124,6 +124,7 @@ dunce = "1.0.3"
 either = "1.9.0"
 futures = "0.3.31"
 git2 = { version = "0.20.4", default-features = false }
+gix-index = { version = "0.47.0", default-features = false }
 hex = "0.4.3"
 httpmock = { version = "0.8.0", default-features = false }
 indicatif = "0.18.3"

Cargo.toml

@@ -605,6 +605,7 @@ impl APIClient {
     /// Builds a shared HTTP client with optional connect timeout. This is
     /// the single TLS initialization point — all consumers should share the
     /// resulting client.
+    #[tracing::instrument(skip_all)]
     pub fn build_http_client(connect_timeout: Option<Duration>) -> Result<reqwest::Client> {
         let mut builder = reqwest::Client::builder();
         if let Some(dur) = connect_timeout {

crates/turborepo-api-client/src/lib.rs

@@ -119,12 +119,12 @@ mod tests {
     // Mock the turborepo_dirs functions for testing
     fn create_mock_vercel_config_dir() -> AbsoluteSystemPathBuf {
         let tmp_dir = tempdir().expect("Failed to create temp dir");
-        AbsoluteSystemPathBuf::try_from(tmp_dir.into_path()).expect("Failed to create path")
+        AbsoluteSystemPathBuf::try_from(tmp_dir.keep()).expect("Failed to create path")
     }
 
     fn create_mock_turbo_config_dir() -> AbsoluteSystemPathBuf {
         let tmp_dir = tempdir().expect("Failed to create temp dir");
-        AbsoluteSystemPathBuf::try_from(tmp_dir.into_path()).expect("Failed to create path")
+        AbsoluteSystemPathBuf::try_from(tmp_dir.keep()).expect("Failed to create path")
     }
 
     fn setup_auth_file(

crates/turborepo-auth/src/auth/mod.rs

@@ -49,4 +49,4 @@ turbopath = { workspace = true }
 turborepo-analytics = { workspace = true }
 turborepo-api-client = { workspace = true }
 turborepo-auth = { workspace = true }
-zstd = "0.12.3"
+zstd = "0.13.3"

crates/turborepo-cache/Cargo.toml

@@ -63,6 +63,9 @@ pub struct CacheDirResult {
     /// This is used for messaging to inform users when worktree cache sharing
     /// is active.
     pub is_shared_worktree: bool,
+    /// The git repository root, if detected during worktree resolution.
+    /// Captured here so `SCM::new` can skip its own `git rev-parse` call.
+    pub git_root: Option<AbsoluteSystemPathBuf>,
 }
 
 /// Configuration errors for turborepo.
@@ -357,8 +360,8 @@ impl ConfigurationOptions {
         self.env_mode.unwrap_or_default()
     }
 
-    /// Returns the default cache directory path (relative to repo root).
-    const DEFAULT_CACHE_DIR: &'static str = if cfg!(windows) {
+    /// The default cache directory path (relative to repo root).
+    pub const DEFAULT_CACHE_DIR: &'static str = if cfg!(windows) {
         ".turbo\\cache"
     } else {
         ".turbo/cache"
@@ -388,58 +391,76 @@ impl ConfigurationOptions {
     /// - `path`: The resolved cache directory path
     /// - `is_shared_worktree`: True if using shared cache from main worktree
     pub fn resolve_cache_dir(&self, repo_root: &AbsoluteSystemPath) -> CacheDirResult {
-        // If explicit cacheDir is configured, always use it (no worktree sharing)
         if let Some(explicit_cache_dir) = &self.cache_dir {
             return CacheDirResult {
                 path: explicit_cache_dir.clone(),
                 is_shared_worktree: false,
+                git_root: None,
             };
         }
 
-        // Try to detect worktree configuration
-        match WorktreeInfo::detect(repo_root) {
-            Ok(worktree_info) => {
+        let worktree_info = WorktreeInfo::detect(repo_root).ok();
+        self.resolve_cache_dir_with_worktree_info(worktree_info.as_ref())
+    }
+
+    /// Resolve cache directory using pre-computed worktree info.
+    ///
+    /// This variant avoids spawning a git subprocess, which allows the caller
+    /// to run worktree detection on a background thread and pass the result in.
+    pub fn resolve_cache_dir_with_worktree_info(
+        &self,
+        worktree_info: Option<&WorktreeInfo>,
+    ) -> CacheDirResult {
+        if let Some(explicit_cache_dir) = &self.cache_dir {
+            return CacheDirResult {
+                path: explicit_cache_dir.clone(),
+                is_shared_worktree: false,
+                git_root: None,
+            };
+        }
+
+        match worktree_info {
+            Some(worktree_info) => {
                 debug!(
                     "Worktree detection: current={}, main={}, is_linked={}",
                     worktree_info.worktree_root,
                     worktree_info.main_worktree_root,
                     worktree_info.is_linked_worktree()
                 );
+                let git_root = Some(worktree_info.git_root.clone());
                 if worktree_info.is_linked_worktree() {
-                    // We're in a linked worktree - use the main worktree's cache
-                    // Use turbopath's join_component to ensure consistent path separators
                     let main_cache_path = worktree_info
                         .main_worktree_root
                         .join_component(".turbo")
                         .join_component("cache");
                     let result = CacheDirResult {
                         path: Utf8PathBuf::from(main_cache_path.as_str()),
                         is_shared_worktree: true,
+                        git_root,
                     };
                     debug!("Using shared worktree cache at: {}", result.path);
                     result
                 } else {
-                    // We're in the main worktree - use local cache
                     debug!(
                         "Using local cache (main worktree): {}",
                         Self::DEFAULT_CACHE_DIR
                     );
                     CacheDirResult {
                         path: Utf8PathBuf::from(Self::DEFAULT_CACHE_DIR),
                         is_shared_worktree: false,
+                        git_root,
                     }
                 }
             }
-            Err(e) => {
-                // Detection failed - silently fall back to local cache
-                // This is expected for non-git directories, so we don't warn
+            None => {
                 debug!(
-                    "Could not detect Git worktree configuration, using local cache: {}",
-                    e
+                    "No worktree info available, using local cache: {}",
+                    Self::DEFAULT_CACHE_DIR
                 );
                 CacheDirResult {
                     path: Utf8PathBuf::from(Self::DEFAULT_CACHE_DIR),
                     is_shared_worktree: false,
+                    git_root: None,
                 }
             }
         }
@@ -850,7 +871,10 @@ mod test {
     #[test]
     fn test_resolve_cache_dir_default_returns_relative_path() {
         let tmp_dir = TempDir::new().unwrap();
-        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path())
+            .unwrap()
+            .to_realpath()
+            .unwrap();
 
         // Initialize git repo
         std::process::Command::new("git")
@@ -870,6 +894,56 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_resolve_cache_dir_captures_git_root() {
+        let tmp_dir = TempDir::new().unwrap();
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path())
+            .unwrap()
+            .to_realpath()
+            .unwrap();
+
+        std::process::Command::new("git")
+            .args(["init", "."])
+            .current_dir(&repo_root)
+            .output()
+            .expect("git init failed");
+
+        let config = ConfigurationOptions::default();
+        let result = config.resolve_cache_dir(&repo_root);
+
+        // git_root should be captured from worktree detection so SCM::new
+        // can skip its own git rev-parse subprocess
+        assert!(
+            result.git_root.is_some(),
+            "git_root should be captured when worktree detection succeeds"
+        );
+        assert_eq!(
+            result.git_root.unwrap(),
+            repo_root,
+            "git_root should match repo root in a non-worktree repo"
+        );
+    }
+
+    #[test]
+    fn test_resolve_cache_dir_explicit_skips_git_root() {
+        let tmp_dir = TempDir::new().unwrap();
+        let repo_root = AbsoluteSystemPath::from_std_path(tmp_dir.path()).unwrap();
+
+        let config = ConfigurationOptions {
+            cache_dir: Some(camino::Utf8PathBuf::from("/my/cache")),
+            ..Default::default()
+        };
+
+        let result = config.resolve_cache_dir(repo_root);
+
+        // When explicit cache_dir is set, no worktree detection runs,
+        // so git_root is not available
+        assert!(
+            result.git_root.is_none(),
+            "git_root should be None when explicit cache_dir bypasses detection"
+        );
+    }
+
     /// Integration test that verifies linked worktree returns absolute path to
     /// main cache
     #[test]

crates/turborepo-config/src/lib.rs

@@ -256,13 +256,19 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
 
         let mut visited = HashSet::new();
         let mut engine: Engine<Building, TaskDefinition> = Engine::default();
+        let mut turbo_json_chain_cache: HashMap<PackageName, Vec<&TurboJson>> = HashMap::new();
 
         while let Some(task_id) = traversal_queue.pop_front() {
             {
                 let (task_id, span) = task_id.clone().split();
                 engine.add_task_location(task_id.into_owned(), span);
             }
 
+            // Skip before doing expensive work if we've already processed this task.
+            if visited.contains(task_id.as_inner()) {
+                continue;
+            }
+
             // For root tasks, verify they are either explicitly enabled OR (when using
             // add_all_tasks mode like devtools) have a definition in root turbo.json.
             // Tasks defined without the //#  prefix (like "transit") in root turbo.json
@@ -323,17 +329,13 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
                 )));
             }
 
-            let task_definition = self.task_definition(
+            let task_definition = self.task_definition_cached(
                 turbo_json_loader,
                 &task_id,
                 &task_id.as_non_workspace_task_name(),
+                &mut turbo_json_chain_cache,
             )?;
 
-            // Skip this iteration of the loop if we've already seen this taskID
-            if visited.contains(task_id.as_inner()) {
-                continue;
-            }
-
             visited.insert(task_id.as_inner().clone());
 
             // Note that the Go code has a whole if/else statement for putting stuff into
@@ -576,19 +578,51 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
         Ok(TaskDefinitionResult::not_found())
     }
 
-    fn task_definition(
+    /// Resolves the merged `TaskDefinition` for a task, caching the turbo.json
+    /// chain per package. The chain only depends on the package name (not the
+    /// task), so multiple tasks in the same package share the cached chain.
+    fn task_definition_cached<'b>(
         &self,
-        turbo_json_loader: &L,
+        turbo_json_loader: &'b L,
         task_id: &Spanned<TaskId>,
         task_name: &TaskName,
+        chain_cache: &mut HashMap<PackageName, Vec<&'b TurboJson>>,
     ) -> Result<TaskDefinition, BuilderError> {
         let processed_task_definition = ProcessedTaskDefinition::from_iter(
-            self.task_definition_chain(turbo_json_loader, task_id, task_name)?,
+            self.task_definition_chain_cached(turbo_json_loader, task_id, task_name, chain_cache)?,
         );
         let path_to_root = self.path_to_root(task_id.as_inner())?;
         TaskDefinition::from_processed(processed_task_definition, &path_to_root)
     }
 
+    /// Like `task_definition_chain` but caches the turbo.json chain per
+    /// package.
+    fn task_definition_chain_cached<'b>(
+        &self,
+        turbo_json_loader: &'b L,
+        task_id: &Spanned<TaskId>,
+        task_name: &TaskName,
+        chain_cache: &mut HashMap<PackageName, Vec<&'b TurboJson>>,
+    ) -> Result<Vec<ProcessedTaskDefinition>, BuilderError> {
+        let package_name = PackageName::from(task_id.package());
+        let turbo_json_chain = match chain_cache.get(&package_name) {
+            Some(cached) => cached.clone(),
+            None => {
+                let chain = self.turbo_json_chain(turbo_json_loader, &package_name)?;
+                chain_cache.insert(package_name, chain.clone());
+                chain
+            }
+        };
+
+        Self::resolve_task_definitions_from_chain(
+            turbo_json_chain,
+            task_id,
+            task_name,
+            self.is_single,
+            self.should_validate_engine,
+        )
+    }
+
     pub fn task_definition_chain(
         &self,
         turbo_json_loader: &L,
@@ -597,6 +631,25 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
     ) -> Result<Vec<ProcessedTaskDefinition>, BuilderError> {
         let package_name = PackageName::from(task_id.package());
         let turbo_json_chain = self.turbo_json_chain(turbo_json_loader, &package_name)?;
+        Self::resolve_task_definitions_from_chain(
+            turbo_json_chain,
+            task_id,
+            task_name,
+            self.is_single,
+            self.should_validate_engine,
+        )
+    }
+
+    /// Given a resolved turbo.json chain for a package, extract the task
+    /// definitions for a specific task by walking the chain and handling
+    /// `extends: false`.
+    fn resolve_task_definitions_from_chain(
+        turbo_json_chain: Vec<&TurboJson>,
+        task_id: &Spanned<TaskId>,
+        task_name: &TaskName,
+        is_single: bool,
+        should_validate_engine: bool,
+    ) -> Result<Vec<ProcessedTaskDefinition>, BuilderError> {
         let mut task_definitions = Vec::new();
 
         // Find the first package in the chain (iterating in reverse from leaf to root)
@@ -645,7 +698,7 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
             task_definitions.push(root_definition)
         }
 
-        if self.is_single {
+        if is_single {
             return match task_definitions.is_empty() {
                 true => {
                     let (span, text) = task_id.span_and_text("turbo.json");
@@ -667,7 +720,7 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
             }
         }
 
-        if task_definitions.is_empty() && self.should_validate_engine {
+        if task_definitions.is_empty() && should_validate_engine {
             let (span, text) = task_id.span_and_text("turbo.json");
             return Err(BuilderError::MissingPackageTask(Box::new(
                 MissingPackageTaskError {

crates/turborepo-engine/src/builder.rs

@@ -63,6 +63,7 @@ impl<T: TaskDefinitionInfo + Clone + Send + Sync + 'static> Engine<Built, T> {
     // finish even once a task sends back the stop signal. This is suboptimal
     // since it would mean the visitor would need to also track if
     // it is cancelled :)
+    #[tracing::instrument(skip_all)]
     pub async fn execute(
         self: Arc<Self>,
         options: ExecutionOptions,

crates/turborepo-engine/src/execute.rs

@@ -440,6 +440,24 @@ fn needs_path_cleaning(s: &str) -> bool {
     false
 }
 
+/// Returns true if the pattern contains glob metacharacters (*, ?, [, {).
+/// Literal file paths return false.
+pub fn is_glob_pattern(pattern: &str) -> bool {
+    // Check for unescaped glob metacharacters
+    let mut chars = pattern.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '\\' {
+            // Skip escaped character
+            chars.next();
+            continue;
+        }
+        if matches!(c, '*' | '?' | '[' | '{') {
+            return true;
+        }
+    }
+    false
+}
+
 pub fn globwalk_with_settings(
     base_path: &AbsoluteSystemPath,
     include: &[ValidatedGlob],