refactor(turborepo): derive Opts from Config (#8759)

### Description

Changed `Opts` to be derived from more than just `RunArgs` and
`ExecutionArgs`. This means that `Opts` contains the fully resolved
config, which gets rid of some messy mutable logic in `RunBuilder` and
creates a single source of truth.

### Testing Instructions

Existing tests cover this pretty well.

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

@@ -123,6 +123,16 @@ pub struct APIAuth {
     pub team_slug: Option<String>,
 }
 
+impl std::fmt::Debug for APIAuth {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("APIAuth")
+            .field("team_id", &self.team_id)
+            .field("token", &"***")
+            .field("team_slug", &self.team_slug)
+            .finish()
+    }
+}
+
 pub fn is_linked(api_auth: &Option<APIAuth>) -> bool {
     api_auth
         .as_ref()

crates/turborepo-lib/src/cli/mod.rs

@@ -682,8 +682,8 @@ pub struct ExecutionArgs {
     /// Environment variable mode.
     /// Use "loose" to pass the entire existing environment.
     /// Use "strict" to use an allowlist specified in turbo.json.
-    #[clap(long = "env-mode", default_value = "strict", num_args = 0..=1, default_missing_value = "strict")]
-    pub env_mode: EnvMode,
+    #[clap(long = "env-mode", num_args = 0..=1, default_missing_value = "strict")]
+    pub env_mode: Option<EnvMode>,
     /// Use the given selector to specify package(s) to act as
     /// entry points. The syntax mirrors pnpm's syntax, and
     /// additional documentation and examples can be found in
@@ -755,8 +755,8 @@ impl ExecutionArgs {
             );
         }
 
-        if self.env_mode != EnvMode::default() {
-            telemetry.track_arg_value("env-mode", self.env_mode, EventType::NonSensitive);
+        if let Some(env_mode) = self.env_mode {
+            telemetry.track_arg_value("env-mode", env_mode, EventType::NonSensitive);
         }
 
         if let Some(output_logs) = &self.output_logs {
@@ -1443,7 +1443,7 @@ mod test {
             command: Some(Command::Run {
                 execution_args: Box::new(ExecutionArgs {
                     tasks: vec!["build".to_string()],
-                    env_mode: EnvMode::Strict,
+                    env_mode: Some(EnvMode::Strict),
                     ..get_default_execution_args()
                 }),
                 run_args: Box::new(get_default_run_args())
@@ -1452,28 +1452,13 @@ mod test {
         } ;
         "env_mode: not fully-specified"
     )]
-    #[test_case::test_case(
-		&["turbo", "run", "build"],
-        Args {
-            command: Some(Command::Run {
-                execution_args: Box::new(ExecutionArgs {
-                    tasks: vec!["build".to_string()],
-                    env_mode: EnvMode::Strict,
-                    ..get_default_execution_args()
-                }),
-                run_args: Box::new(get_default_run_args())
-            }),
-            ..Args::default()
-		} ;
-        "env_mode: default strict"
-	)]
     #[test_case::test_case(
 		&["turbo", "run", "build", "--env-mode", "loose"],
         Args {
             command: Some(Command::Run {
                 execution_args: Box::new(ExecutionArgs {
                     tasks: vec!["build".to_string()],
-                    env_mode: EnvMode::Loose,
+                    env_mode: Some(EnvMode::Loose),
                     ..get_default_execution_args()
                 }),
                 run_args: Box::new(get_default_run_args())
@@ -1488,7 +1473,7 @@ mod test {
             command: Some(Command::Run {
                 execution_args: Box::new(ExecutionArgs {
                     tasks: vec!["build".to_string()],
-                    env_mode: EnvMode::Strict,
+                    env_mode: Some(EnvMode::Strict),
                     ..get_default_execution_args()
                 }),
                 run_args: Box::new(get_default_run_args())

crates/turborepo-lib/src/opts.rs

@@ -2,14 +2,16 @@ use std::{backtrace, backtrace::Backtrace};
 
 use thiserror::Error;
 use turbopath::AnchoredSystemPathBuf;
-use turborepo_cache::CacheOpts;
+use turborepo_api_client::APIAuth;
+use turborepo_cache::{CacheOpts, RemoteCacheOpts};
 
 use crate::{
     cli::{
         Command, DryRunMode, EnvMode, ExecutionArgs, LogOrder, LogPrefix, OutputLogsMode, RunArgs,
     },
+    commands::CommandBase,
+    config::ConfigurationOptions,
     run::task_id::TaskId,
-    Args,
 };
 
 #[derive(Debug, Error)]
@@ -30,6 +32,8 @@ pub enum Error {
     ConcurrencyOutOfBounds(#[backtrace] backtrace::Backtrace, String),
     #[error(transparent)]
     Path(#[from] turbopath::PathError),
+    #[error(transparent)]
+    Config(#[from] crate::config::Error),
 }
 
 #[derive(Debug)]
@@ -76,20 +80,25 @@ impl Opts {
     }
 }
 
-impl<'a> TryFrom<&'a Args> for Opts {
-    type Error = self::Error;
+impl Opts {
+    pub fn new(base: &CommandBase) -> Result<Self, Error> {
+        let args = base.args();
+        let config = base.config()?;
+        let api_auth = base.api_auth()?;
 
-    fn try_from(args: &'a Args) -> Result<Self, Self::Error> {
         let Some(Command::Run {
             run_args,
             execution_args,
         }) = &args.command
         else {
             return Err(Error::ExpectedRun(Backtrace::capture()));
         };
-        let run_and_execution_args = RunAndExecutionArgs {
+
+        let run_and_execution_args = OptsInputs {
             run_args: run_args.as_ref(),
             execution_args: execution_args.as_ref(),
+            config,
+            api_auth: &api_auth,
         };
         let run_opts = RunOpts::try_from(run_and_execution_args)?;
         let cache_opts = CacheOpts::from(run_and_execution_args);
@@ -105,11 +114,12 @@ impl<'a> TryFrom<&'a Args> for Opts {
     }
 }
 
-// This is not ideal, but it allows us to impl From
 #[derive(Debug, Clone, Copy)]
-struct RunAndExecutionArgs<'a> {
+struct OptsInputs<'a> {
     run_args: &'a RunArgs,
     execution_args: &'a ExecutionArgs,
+    config: &'a ConfigurationOptions,
+    api_auth: &'a Option<APIAuth>,
 }
 
 #[derive(Debug, Default)]
@@ -119,12 +129,12 @@ pub struct RunCacheOpts {
     pub(crate) task_output_logs_override: Option<OutputLogsMode>,
 }
 
-impl<'a> From<RunAndExecutionArgs<'a>> for RunCacheOpts {
-    fn from(args: RunAndExecutionArgs<'a>) -> Self {
+impl<'a> From<OptsInputs<'a>> for RunCacheOpts {
+    fn from(inputs: OptsInputs<'a>) -> Self {
         RunCacheOpts {
-            skip_reads: args.execution_args.force.flatten().is_some_and(|f| f),
-            skip_writes: args.run_args.no_cache,
-            task_output_logs_override: args.execution_args.output_logs,
+            skip_reads: inputs.execution_args.force.flatten().is_some_and(|f| f),
+            skip_writes: inputs.run_args.no_cache,
+            task_output_logs_override: inputs.execution_args.output_logs,
         }
     }
 }
@@ -187,28 +197,28 @@ pub enum ResolvedLogPrefix {
 
 const DEFAULT_CONCURRENCY: u32 = 10;
 
-impl<'a> TryFrom<RunAndExecutionArgs<'a>> for RunOpts {
+impl<'a> TryFrom<OptsInputs<'a>> for RunOpts {
     type Error = self::Error;
 
-    fn try_from(args: RunAndExecutionArgs) -> Result<Self, Self::Error> {
-        let concurrency = args
+    fn try_from(inputs: OptsInputs) -> Result<Self, Self::Error> {
+        let concurrency = inputs
             .execution_args
             .concurrency
             .as_deref()
             .map(parse_concurrency)
             .transpose()?
             .unwrap_or(DEFAULT_CONCURRENCY);
 
-        let graph = args.run_args.graph.as_deref().map(|file| match file {
+        let graph = inputs.run_args.graph.as_deref().map(|file| match file {
             "" => GraphOpts::Stdout,
             f => GraphOpts::File(f.to_string()),
         });
 
-        let (is_github_actions, log_order, log_prefix) = match args.execution_args.log_order {
+        let (is_github_actions, log_order, log_prefix) = match inputs.execution_args.log_order {
             LogOrder::Auto if turborepo_ci::Vendor::get_constant() == Some("GITHUB_ACTIONS") => (
                 true,
                 ResolvedLogOrder::Grouped,
-                match args.execution_args.log_prefix {
+                match inputs.execution_args.log_prefix {
                     LogPrefix::Task => ResolvedLogPrefix::Task,
                     _ => ResolvedLogPrefix::None,
                 },
@@ -218,33 +228,37 @@ impl<'a> TryFrom<RunAndExecutionArgs<'a>> for RunOpts {
             LogOrder::Auto | LogOrder::Stream => (
                 false,
                 ResolvedLogOrder::Stream,
-                args.execution_args.log_prefix.into(),
+                inputs.execution_args.log_prefix.into(),
             ),
             LogOrder::Grouped => (
                 false,
                 ResolvedLogOrder::Grouped,
-                args.execution_args.log_prefix.into(),
+                inputs.execution_args.log_prefix.into(),
             ),
         };
 
         Ok(Self {
-            tasks: args.execution_args.tasks.clone(),
+            tasks: inputs.execution_args.tasks.clone(),
             log_prefix,
             log_order,
-            summarize: args.run_args.summarize,
-            experimental_space_id: args.run_args.experimental_space_id.clone(),
-            framework_inference: args.execution_args.framework_inference,
-            env_mode: args.execution_args.env_mode,
+            summarize: inputs.run_args.summarize,
+            experimental_space_id: inputs
+                .run_args
+                .experimental_space_id
+                .clone()
+                .or(inputs.config.spaces_id().map(|s| s.to_owned())),
+            framework_inference: inputs.execution_args.framework_inference,
             concurrency,
-            parallel: args.run_args.parallel,
-            profile: args.run_args.profile.clone(),
-            continue_on_error: args.execution_args.continue_execution,
-            pass_through_args: args.execution_args.pass_through_args.clone(),
-            only: args.execution_args.only,
-            daemon: args.run_args.daemon(),
-            single_package: args.execution_args.single_package,
+            parallel: inputs.run_args.parallel,
+            profile: inputs.run_args.profile.clone(),
+            continue_on_error: inputs.execution_args.continue_execution,
+            pass_through_args: inputs.execution_args.pass_through_args.clone(),
+            only: inputs.execution_args.only,
+            daemon: inputs.run_args.daemon(),
+            single_package: inputs.execution_args.single_package,
             graph,
-            dry_run: args.run_args.dry_run,
+            dry_run: inputs.run_args.dry_run,
+            env_mode: inputs.execution_args.env_mode.unwrap_or_default(),
             is_github_actions,
         })
     }
@@ -288,33 +302,56 @@ pub struct ScopeOpts {
     pub filter_patterns: Vec<String>,
 }
 
-impl<'a> TryFrom<RunAndExecutionArgs<'a>> for ScopeOpts {
+impl<'a> TryFrom<OptsInputs<'a>> for ScopeOpts {
     type Error = self::Error;
 
-    fn try_from(args: RunAndExecutionArgs<'a>) -> Result<Self, Self::Error> {
-        let pkg_inference_root = args
+    fn try_from(inputs: OptsInputs<'a>) -> Result<Self, Self::Error> {
+        let pkg_inference_root = inputs
             .execution_args
             .pkg_inference_root
             .as_ref()
             .map(AnchoredSystemPathBuf::from_raw)
             .transpose()?;
 
         Ok(Self {
-            global_deps: args.execution_args.global_deps.clone(),
+            global_deps: inputs.execution_args.global_deps.clone(),
             pkg_inference_root,
-            filter_patterns: args.execution_args.filter.clone(),
+            filter_patterns: inputs.execution_args.filter.clone(),
         })
     }
 }
 
-impl<'a> From<RunAndExecutionArgs<'a>> for CacheOpts {
-    fn from(args: RunAndExecutionArgs<'a>) -> Self {
+impl<'a> From<OptsInputs<'a>> for CacheOpts {
+    fn from(inputs: OptsInputs<'a>) -> Self {
+        let is_linked = turborepo_api_client::is_linked(inputs.api_auth);
+        let skip_remote = if !is_linked {
+            true
+        } else if let Some(enabled) = inputs.config.enabled {
+            // We're linked, but if the user has explicitly enabled or disabled, use that
+            // value
+            !enabled
+        } else {
+            false
+        };
+
+        // Note that we don't currently use the team_id value here. In the future, we
+        // should probably verify that we only use the signature value when the
+        // configured team_id matches the final resolved team_id.
+        let unused_remote_cache_opts_team_id =
+            inputs.config.team_id().map(|team_id| team_id.to_string());
+        let signature = inputs.config.signature();
+        let remote_cache_opts = Some(RemoteCacheOpts::new(
+            unused_remote_cache_opts_team_id,
+            signature,
+        ));
+
         CacheOpts {
-            override_dir: args.execution_args.cache_dir.clone(),
-            skip_filesystem: args.execution_args.remote_only,
-            remote_cache_read_only: args.run_args.remote_cache_read_only,
-            workers: args.run_args.cache_workers,
-            ..CacheOpts::default()
+            override_dir: inputs.execution_args.cache_dir.clone(),
+            skip_filesystem: inputs.execution_args.remote_only,
+            remote_cache_read_only: inputs.run_args.remote_cache_read_only,
+            workers: inputs.run_args.cache_workers,
+            skip_remote,
+            remote_cache_opts,
         }
     }
 }

crates/turborepo-lib/src/run/builder.rs

@@ -10,7 +10,7 @@ use tracing::debug;
 use turbopath::{AbsoluteSystemPathBuf, AnchoredSystemPath};
 use turborepo_analytics::{start_analytics, AnalyticsHandle, AnalyticsSender};
 use turborepo_api_client::{APIAuth, APIClient};
-use turborepo_cache::{AsyncCache, RemoteCacheOpts};
+use turborepo_cache::AsyncCache;
 use turborepo_env::EnvironmentVariableMap;
 use turborepo_errors::Spanned;
 use turborepo_repository::{
@@ -69,33 +69,13 @@ pub struct RunBuilder {
 
 impl RunBuilder {
     pub fn new(base: CommandBase) -> Result<Self, Error> {
-        let api_auth = base.api_auth()?;
         let api_client = base.api_client()?;
 
-        let mut opts: Opts = base.args().try_into()?;
+        let opts = Opts::new(&base)?;
+        let api_auth = base.api_auth()?;
         let config = base.config()?;
         let allow_missing_package_manager = config.allow_no_package_manager();
 
-        let is_linked = turborepo_api_client::is_linked(&api_auth);
-        if !is_linked {
-            opts.cache_opts.skip_remote = true;
-        } else if let Some(enabled) = config.enabled {
-            // We're linked, but if the user has explicitly enabled or disabled, use that
-            // value
-            opts.cache_opts.skip_remote = !enabled;
-        }
-        // Note that we don't currently use the team_id value here. In the future, we
-        // should probably verify that we only use the signature value when the
-        // configured team_id matches the final resolved team_id.
-        let unused_remote_cache_opts_team_id = config.team_id().map(|team_id| team_id.to_string());
-        let signature = config.signature();
-        opts.cache_opts.remote_cache_opts = Some(RemoteCacheOpts::new(
-            unused_remote_cache_opts_team_id,
-            signature,
-        ));
-        if opts.run_opts.experimental_space_id.is_none() {
-            opts.run_opts.experimental_space_id = config.spaces_id().map(|s| s.to_owned());
-        }
         let version = base.version();
         let experimental_ui = config.ui();
         let processes = ProcessManager::new(
@@ -111,11 +91,11 @@ impl RunBuilder {
             processes,
             opts,
             api_client,
-            api_auth,
             repo_root,
             ui,
             version,
             experimental_ui,
+            api_auth,
             analytics_sender: None,
             entrypoint_packages: None,
             should_print_prelude_override: None,