vercel · chris-olszewski · Jul 30, 2025 · Jul 29, 2025 · Jul 29, 2025 · Jul 29, 2025
@@ -65,6 +65,7 @@ turborepo-lockfiles = { path = "crates/turborepo-lockfiles" }
 turborepo-microfrontends = { path = "crates/turborepo-microfrontends" }
 turborepo-process = { path = "crates/turborepo-process" }
 turborepo-repository = { path = "crates/turborepo-repository" }
+turborepo-task-id = { path = "crates/turborepo-task-id" }
 turborepo-ui = { path = "crates/turborepo-ui" }
 turborepo-unescape = { path = "crates/turborepo-unescape" }
 turborepo-scm = { path = "crates/turborepo-scm" }

@@ -141,6 +141,7 @@ turborepo-process = { workspace = true }
 turborepo-repository = { path = "../turborepo-repository" }
 turborepo-scm = { workspace = true, features = ["git2"] }
 turborepo-signals = { workspace = true }
+turborepo-task-id = { workspace = true }
 turborepo-telemetry = { path = "../turborepo-telemetry" }
 turborepo-ui = { workspace = true }
 turborepo-unescape = { workspace = true }

@@ -8,9 +8,11 @@ use turborepo_ui::ColorConfig;
 
 use crate::{
     cli,
-    config::{ConfigurationOptions, Error as ConfigError, TurborepoConfigBuilder},
+    config::{
+        resolve_turbo_config_path, ConfigurationOptions, Error as ConfigError,
+        TurborepoConfigBuilder,
+    },
     opts::Opts,
-    turbo_json::resolve_turbo_config_path,
     Args,
 };
 

@@ -16,7 +16,10 @@ use turborepo_telemetry::events::command::CommandEventBuilder;
 use turborepo_ui::BOLD;
 
 use super::CommandBase;
-use crate::turbo_json::{RawTurboJson, CONFIG_FILE, CONFIG_FILE_JSONC};
+use crate::{
+    config::{CONFIG_FILE, CONFIG_FILE_JSONC},
+    turbo_json::RawTurboJson,
+};
 
 pub const DEFAULT_OUTPUT_DIR: &str = "out";
 

@@ -23,11 +23,11 @@ use turborepo_cache::CacheConfig;
 use turborepo_errors::TURBO_SITE;
 use turborepo_repository::package_graph::PackageName;
 
+use crate::cli::{EnvMode, LogOrder};
 pub use crate::turbo_json::{RawTurboJson, UIMode};
-use crate::{
-    cli::{EnvMode, LogOrder},
-    turbo_json::resolve_turbo_config_path,
-};
+
+pub const CONFIG_FILE: &str = "turbo.json";
+pub const CONFIG_FILE_JSONC: &str = "turbo.jsonc";
 
 #[derive(Debug, Error, Diagnostic)]
 #[error("Environment variables should not be prefixed with \"{env_pipeline_delimiter}\"")]
@@ -566,19 +566,42 @@ impl TurborepoConfigBuilder {
     }
 }
 
+/// Given a directory path, determines which turbo.json configuration file to
+/// use. Returns an error if both turbo.json and turbo.jsonc exist in the same
+/// directory. Returns the path to the config file to use, defaulting to
+/// turbo.json if neither exists.
+pub fn resolve_turbo_config_path(
+    dir_path: &turbopath::AbsoluteSystemPath,
+) -> Result<turbopath::AbsoluteSystemPathBuf, crate::config::Error> {
+    use crate::config::Error;
+
+    let turbo_json_path = dir_path.join_component(CONFIG_FILE);
+    let turbo_jsonc_path = dir_path.join_component(CONFIG_FILE_JSONC);
+
+    let turbo_json_exists = turbo_json_path.try_exists()?;
+    let turbo_jsonc_exists = turbo_jsonc_path.try_exists()?;
+
+    match (turbo_json_exists, turbo_jsonc_exists) {
+        (true, true) => Err(Error::MultipleTurboConfigs {
+            directory: dir_path.to_string(),
+        }),
+        (true, false) => Ok(turbo_json_path),
+        (false, true) => Ok(turbo_jsonc_path),
+        // Default to turbo.json if neither exists
+        (false, false) => Ok(turbo_json_path),
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::{collections::HashMap, ffi::OsString};
 
     use tempfile::TempDir;
     use turbopath::{AbsoluteSystemPath, AbsoluteSystemPathBuf};
 
-    use crate::{
-        config::{
-            ConfigurationOptions, TurborepoConfigBuilder, DEFAULT_API_URL, DEFAULT_LOGIN_URL,
-            DEFAULT_TIMEOUT,
-        },
-        turbo_json::{CONFIG_FILE, CONFIG_FILE_JSONC},
+    use crate::config::{
+        ConfigurationOptions, TurborepoConfigBuilder, CONFIG_FILE, CONFIG_FILE_JSONC,
+        DEFAULT_API_URL, DEFAULT_LOGIN_URL, DEFAULT_TIMEOUT,
     };
 
     #[test]

@@ -2,12 +2,44 @@ use camino::Utf8PathBuf;
 use turbopath::{AbsoluteSystemPath, RelativeUnixPath};
 
 use super::{ConfigurationOptions, Error, ResolvedConfigurationOptions};
-use crate::turbo_json::RawTurboJson;
+use crate::turbo_json::{RawRemoteCacheOptions, RawTurboJson};
 
 pub struct TurboJsonReader<'a> {
     repo_root: &'a AbsoluteSystemPath,
 }
 
+impl From<&RawRemoteCacheOptions> for ConfigurationOptions {
+    fn from(remote_cache_opts: &RawRemoteCacheOptions) -> Self {
+        Self {
+            api_url: remote_cache_opts
+                .api_url
+                .as_ref()
+                .map(|s| s.as_inner().clone()),
+            login_url: remote_cache_opts
+                .login_url
+                .as_ref()
+                .map(|s| s.as_inner().clone()),
+            team_slug: remote_cache_opts
+                .team_slug
+                .as_ref()
+                .map(|s| s.as_inner().clone()),
+            team_id: remote_cache_opts
+                .team_id
+                .as_ref()
+                .map(|s| s.as_inner().clone()),
+            signature: remote_cache_opts.signature.as_ref().map(|s| *s.as_inner()),
+            preflight: remote_cache_opts.preflight.as_ref().map(|s| *s.as_inner()),
+            timeout: remote_cache_opts.timeout.as_ref().map(|s| *s.as_inner()),
+            upload_timeout: remote_cache_opts
+                .upload_timeout
+                .as_ref()
+                .map(|s| *s.as_inner()),
+            enabled: remote_cache_opts.enabled.as_ref().map(|s| *s.as_inner()),
+            ..Self::default()
+        }
+    }
+}
+
 impl<'a> TurboJsonReader<'a> {
     pub fn new(repo_root: &'a AbsoluteSystemPath) -> Self {
         Self { repo_root }
@@ -68,7 +100,7 @@ mod test {
     use tempfile::tempdir;
 
     use super::*;
-    use crate::turbo_json::CONFIG_FILE;
+    use crate::config::CONFIG_FILE;
 
     #[test]
     fn test_reads_from_default() {

@@ -7,11 +7,11 @@ use turbopath::{AbsoluteSystemPath, AnchoredSystemPathBuf, RelativeUnixPathBuf};
 use turborepo_errors::{Spanned, TURBO_SITE};
 use turborepo_graph_utils as graph;
 use turborepo_repository::package_graph::{PackageGraph, PackageName, PackageNode, ROOT_PKG_NAME};
+use turborepo_task_id::{TaskId, TaskName};
 
 use super::Engine;
 use crate::{
     config,
-    run::task_id::{TaskId, TaskName},
     task_graph::TaskDefinition,
     turbo_json::{
         validate_extends, validate_no_package_task_syntax, validate_with_has_no_topo,

@@ -4,9 +4,9 @@ use futures::{stream::FuturesUnordered, StreamExt};
 use tokio::sync::{mpsc, oneshot, Semaphore};
 use tracing::log::debug;
 use turborepo_graph_utils::Walker;
+use turborepo_task_id::TaskId;
 
 use super::{Engine, TaskNode};
-use crate::run::task_id::TaskId;
 
 pub struct Message<T, U> {
     pub info: T,

@@ -16,8 +16,9 @@ use petgraph::Graph;
 use thiserror::Error;
 use turborepo_errors::Spanned;
 use turborepo_repository::package_graph::{PackageGraph, PackageName};
+use turborepo_task_id::TaskId;
 
-use crate::{run::task_id::TaskId, task_graph::TaskDefinition, turbo_json::UIMode};
+use crate::{task_graph::TaskDefinition, turbo_json::UIMode};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum TaskNode {
@@ -612,9 +613,9 @@ mod test {
         discovery::{DiscoveryResponse, PackageDiscovery, WorkspaceData},
         package_json::PackageJson,
     };
+    use turborepo_task_id::TaskName;
 
     use super::*;
-    use crate::run::task_id::TaskName;
 
     struct DummyDiscovery<'a>(&'a TempDir);
 

@@ -5,12 +5,9 @@ use tracing::warn;
 use turbopath::{AbsoluteSystemPath, RelativeUnixPath, RelativeUnixPathBuf};
 use turborepo_microfrontends::{Config as MFEConfig, Error, MICROFRONTENDS_PACKAGE};
 use turborepo_repository::package_graph::{PackageGraph, PackageName};
+use turborepo_task_id::{TaskId, TaskName};
 
-use crate::{
-    config,
-    run::task_id::{TaskId, TaskName},
-    turbo_json::TurboJson,
-};
+use crate::{config, turbo_json::TurboJson};
 
 #[derive(Debug, Clone)]
 pub struct MicrofrontendsConfigs {
@@ -309,7 +306,7 @@ mod test {
                 $(
                     let mut _dev_tasks = std::collections::HashMap::new();
                     for _dev_task in $dev_tasks.as_slice() {
-                        let _dev_task_id = crate::run::task_id::TaskName::from(*_dev_task).task_id().unwrap().into_owned();
+                        let _dev_task_id = turborepo_task_id::TaskName::from(*_dev_task).task_id().unwrap().into_owned();
                         let _dev_application = _dev_task_id.package().to_owned();
                         _dev_tasks.insert(_dev_task_id, _dev_application);
                     }
@@ -382,7 +379,7 @@ mod test {
         }
 
         fn str_to_task(s: &str) -> TaskId<'static> {
-            crate::run::task_id::TaskName::from(s)
+            turborepo_task_id::TaskName::from(s)
                 .task_id()
                 .unwrap()
                 .into_owned()

@@ -6,15 +6,15 @@ use thiserror::Error;
 use turbopath::{AbsoluteSystemPath, AbsoluteSystemPathBuf, AnchoredSystemPathBuf};
 use turborepo_api_client::APIAuth;
 use turborepo_cache::{CacheOpts, RemoteCacheOpts};
+use turborepo_task_id::{TaskId, TaskName};
 
 use crate::{
     cli::{
         Command, ContinueMode, DryRunMode, EnvMode, ExecutionArgs, LogOrder, LogPrefix,
         OutputLogsMode, RunArgs,
     },
-    config::ConfigurationOptions,
-    run::task_id::{TaskId, TaskName},
-    turbo_json::{UIMode, CONFIG_FILE},
+    config::{ConfigurationOptions, CONFIG_FILE},
+    turbo_json::UIMode,
     Args,
 };
 
@@ -567,16 +567,16 @@ mod test {
     use test_case::test_case;
     use turbopath::AbsoluteSystemPathBuf;
     use turborepo_cache::{CacheActions, CacheConfig, CacheOpts};
+    use turborepo_task_id::TaskId;
     use turborepo_ui::ColorConfig;
 
     use super::{APIClientOpts, RepoOpts, RunOpts, TaskArgs};
     use crate::{
         cli::{Command, ContinueMode, DryRunMode, RunArgs},
         commands::CommandBase,
-        config::ConfigurationOptions,
+        config::{ConfigurationOptions, CONFIG_FILE},
         opts::{Opts, RunCacheOpts, ScopeOpts, TuiOpts},
-        run::task_id::TaskId,
-        turbo_json::{UIMode, CONFIG_FILE},
+        turbo_json::UIMode,
         Args,
     };
 

@@ -23,8 +23,9 @@ use turborepo_repository::{
 };
 use turborepo_scm::GitHashes;
 
-use crate::turbo_json::{
-    resolve_turbo_config_path, TurboJson, TurboJsonLoader, CONFIG_FILE, CONFIG_FILE_JSONC,
+use crate::{
+    config::{resolve_turbo_config_path, CONFIG_FILE, CONFIG_FILE_JSONC},
+    turbo_json::{TurboJson, TurboJsonLoader},
 };
 
 #[derive(Clone)]

@@ -2,11 +2,12 @@ use std::sync::Arc;
 
 use async_graphql::Object;
 use turborepo_errors::Spanned;
+use turborepo_task_id::TaskId;
 
 use crate::{
     engine::TaskNode,
     query::{package::Package, Array, Error},
-    run::{task_id::TaskId, Run},
+    run::Run,
 };
 
 pub struct RepositoryTask {

@@ -22,6 +22,7 @@ use turborepo_repository::{
 };
 use turborepo_scm::SCM;
 use turborepo_signals::{SignalHandler, SignalSubscriber};
+use turborepo_task_id::TaskName;
 use turborepo_telemetry::events::{
     command::CommandEventBuilder,
     generic::{DaemonInitStatus, GenericEventBuilder},
@@ -42,12 +43,13 @@ use {
 use crate::{
     cli::DryRunMode,
     commands::CommandBase,
+    config::resolve_turbo_config_path,
     engine::{Engine, EngineBuilder},
     microfrontends::MicrofrontendsConfigs,
     opts::Opts,
-    run::{scope, task_access::TaskAccess, task_id::TaskName, Error, Run, RunCache},
+    run::{scope, task_access::TaskAccess, Error, Run, RunCache},
     shim::TurboState,
-    turbo_json::{resolve_turbo_config_path, TurboJson, TurboJsonLoader, UIMode},
+    turbo_json::{TurboJson, TurboJsonLoader, UIMode},
     DaemonConnector,
 };
 

@@ -15,6 +15,7 @@ use turborepo_cache::{
 };
 use turborepo_repository::package_graph::PackageInfo;
 use turborepo_scm::SCM;
+use turborepo_task_id::TaskId;
 use turborepo_telemetry::events::{task::PackageTaskEventBuilder, TrackedErrors};
 use turborepo_ui::{color, tui::event::CacheResult, ColorConfig, ColorSelector, LogWriter, GREY};
 
@@ -23,7 +24,6 @@ use crate::{
     daemon::{DaemonClient, DaemonConnector},
     hash::{FileHashes, TurboHash},
     opts::RunCacheOpts,
-    run::task_id::TaskId,
     task_graph::{TaskDefinition, TaskOutputs},
 };
 

@@ -9,7 +9,6 @@ pub(crate) mod package_discovery;
 pub(crate) mod scope;
 pub(crate) mod summary;
 pub mod task_access;
-pub mod task_id;
 mod ui;
 pub mod watch;
 

@@ -4,10 +4,11 @@ use chrono::{DateTime, Local};
 use serde::Serialize;
 use tokio::sync::mpsc;
 use turbopath::{AbsoluteSystemPathBuf, AnchoredSystemPath};
+use turborepo_task_id::TaskId;
 use turborepo_ui::{color, cprintln, ColorConfig, BOLD, BOLD_GREEN, BOLD_RED, MAGENTA, YELLOW};
 
 use super::TurboDuration;
-use crate::run::{summary::task::TaskSummary, task_id::TaskId};
+use crate::run::summary::task::TaskSummary;
 
 // Just used to make changing the type that gets passed to the state management
 // thread easy