perf: Share single reqwest::Client to eliminate redundant TLS initialization

Previously, three separate reqwest::Client instances were built during
startup (API client, cache client, telemetry client), each performing
independent TLS initialization (~100-150ms each on macOS). This was
the single largest contributor to startup latency.

Now a single reqwest::Client is built once in cli::run() and shared
across all consumers via new_with_client() constructors. Per-request
timeouts replace per-client timeouts, preserving the existing timeout
semantics (API timeout for regular calls, upload timeout for cache
uploads).

Includes regression tests covering all client operations: get_user,
get_teams, get_caching_status, put/fetch/exists artifact, telemetry
recording, and timeout configurations.

Author: anthonyshew

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

@@ -91,7 +91,7 @@ pub async fn print_potential_tasks(
     let handler = SignalHandler::new(signal);
     let color_config = base.color_config;
 
-    let run_builder = RunBuilder::new(base)?;
+    let run_builder = RunBuilder::new(base, None)?;
     let run = run_builder.build(&handler, telemetry).await?;
     let potential_tasks = run.get_potential_tasks()?;
 

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

@@ -7,7 +7,7 @@ pub use error::Error;
 use serde::Serialize;
 use tracing::{debug, error, log::warn};
 use turbopath::AbsoluteSystemPathBuf;
-use turborepo_api_client::AnonAPIClient;
+use turborepo_api_client::{APIClient, AnonAPIClient};
 use turborepo_repository::inference::{RepoMode, RepoState};
 use turborepo_telemetry::{
     events::{command::CommandEventBuilder, generic::GenericEventBuilder, EventBuilder, EventType},
@@ -1140,25 +1140,22 @@ impl RunArgs {
 
 #[tracing::instrument(skip_all)]
 fn initialize_telemetry_client(
+    http_client: &reqwest::Client,
     color_config: ColorConfig,
     version: &str,
 ) -> Option<TelemetryHandle> {
-    let mut telemetry_handle: Option<TelemetryHandle> = None;
-    match AnonAPIClient::new("https://telemetry.vercel.com", 250, version) {
-        Ok(anonymous_api_client) => {
-            let handle = init_telemetry(anonymous_api_client, color_config);
-            match handle {
-                Ok(h) => telemetry_handle = Some(h),
-                Err(error) => {
-                    debug!("failed to start telemetry: {:?}", error)
-                }
-            }
-        }
+    let anonymous_api_client = AnonAPIClient::new_with_client(
+        http_client.clone(),
+        "https://telemetry.vercel.com",
+        version,
+    );
+    match init_telemetry(anonymous_api_client, color_config) {
+        Ok(h) => Some(h),
         Err(error) => {
-            debug!("Failed to create AnonAPIClient: {:?}", error);
+            debug!("failed to start telemetry: {:?}", error);
+            None
         }
     }
-    telemetry_handle
 }
 
 #[derive(PartialEq)]
@@ -1305,8 +1302,13 @@ pub async fn run(
     let mut cli_args = Args::new(env::args_os().collect());
     let version = get_version();
 
+    // Build a single HTTP client to share across telemetry, API, and cache
+    // operations. This avoids redundant TLS initialization (~150ms savings).
+    let http_client = APIClient::build_http_client(None)
+        .expect("Failed to create HTTP client: TLS initialization failed");
+
     // track telemetry handle to close at the end of the run
-    let telemetry_handle = initialize_telemetry_client(color_config, version);
+    let telemetry_handle = initialize_telemetry_client(&http_client, color_config, version);
 
     if should_print_version() {
         eprintln!("{}", GREY.apply_to(format!("• turbo {}", get_version())));
@@ -1599,7 +1601,7 @@ pub async fn run(
             }
 
             run_args.track(&event);
-            let exit_code = run::run(base, event).await.inspect(|code| {
+            let exit_code = run::run(base, event, &http_client).await.inspect(|code| {
                 if *code != 0 {
                     error!("run failed: command  exited ({code})");
                 }

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

@@ -18,7 +18,7 @@ pub async fn run(
     let signal = get_signal()?;
     let handler = SignalHandler::new(signal);
 
-    let run = RunBuilder::new(base)?
+    let run = RunBuilder::new(base, None)?
         .do_not_validate_engine()
         .build(&handler, telemetry)
         .await?;

crates/turborepo-lib/src/commands/boundaries.rs

@@ -124,7 +124,7 @@ pub async fn run(
     let signal = get_signal()?;
     let handler = SignalHandler::new(signal);
 
-    let run_builder = RunBuilder::new(base)?;
+    let run_builder = RunBuilder::new(base, None)?;
     let run = run_builder.build(&handler, telemetry).await?;
 
     if packages.is_empty() {

crates/turborepo-lib/src/commands/ls.rs

@@ -142,6 +142,30 @@ impl CommandBase {
         .map_err(ConfigError::ApiClient)
     }
 
+    /// Creates an API client using a pre-built HTTP client to avoid
+    /// redundant TLS initialization.
+    pub fn api_client_with_http(&self, http_client: &reqwest::Client) -> APIClient {
+        let timeout = self.opts.api_client_opts.timeout;
+        let upload_timeout = self.opts.api_client_opts.upload_timeout;
+
+        APIClient::new_with_client(
+            http_client.clone(),
+            &self.opts.api_client_opts.api_url,
+            if timeout > 0 {
+                Some(Duration::from_secs(timeout))
+            } else {
+                None
+            },
+            if upload_timeout > 0 {
+                Some(Duration::from_secs(upload_timeout))
+            } else {
+                None
+            },
+            self.version,
+            self.opts.api_client_opts.preflight,
+        )
+    }
+
     /// Current working directory for the turbo command
     pub fn cwd(&self) -> &AbsoluteSystemPath {
         // Earlier in execution

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

@@ -164,7 +164,7 @@ pub async fn run(
     let signal = get_signal()?;
     let handler = SignalHandler::new(signal);
 
-    let run_builder = RunBuilder::new(base)?
+    let run_builder = RunBuilder::new(base, None)?
         .add_all_tasks()
         .do_not_validate_engine();
     let run = run_builder.build(&handler, telemetry).await?;

crates/turborepo-lib/src/commands/query.rs

@@ -8,11 +8,15 @@ use turborepo_ui::sender::UISender;
 use crate::{commands::CommandBase, run, run::builder::RunBuilder};
 
 #[tracing::instrument(skip_all)]
-pub async fn run(base: CommandBase, telemetry: CommandEventBuilder) -> Result<i32, run::Error> {
+pub async fn run(
+    base: CommandBase,
+    telemetry: CommandEventBuilder,
+    http_client: &reqwest::Client,
+) -> Result<i32, run::Error> {
     let signal = get_signal()?;
     let handler = SignalHandler::new(signal);
 
-    let run_builder = RunBuilder::new(base)?;
+    let run_builder = RunBuilder::new(base, Some(http_client))?;
 
     let run_fut = async {
         let (analytics_sender, analytics_handle) = run_builder.start_analytics();

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

@@ -64,8 +64,11 @@ pub struct RunBuilder {
 
 impl RunBuilder {
     #[tracing::instrument(skip_all)]
-    pub fn new(base: CommandBase) -> Result<Self, Error> {
-        let api_client = base.api_client()?;
+    pub fn new(base: CommandBase, http_client: Option<&reqwest::Client>) -> Result<Self, Error> {
+        let api_client = match http_client {
+            Some(client) => base.api_client_with_http(client),
+            None => base.api_client()?,
+        };
 
         let opts = base.opts();
         let api_auth = base.api_auth()?;

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

@@ -123,7 +123,7 @@ impl WatchClient {
 
         let new_base = base.clone();
         let run = Arc::new(
-            RunBuilder::new(new_base)?
+            RunBuilder::new(new_base, None)?
                 .build(&handler, telemetry.clone())
                 .await?,
         );
@@ -355,7 +355,7 @@ impl WatchClient {
                 let signal_handler = self.handler.clone();
                 let telemetry = self.telemetry.clone();
 
-                let run = RunBuilder::new(new_base)?
+                let run = RunBuilder::new(new_base, None)?
                     .with_entrypoint_packages(packages)
                     .hide_prelude()
                     .build(&signal_handler, telemetry)
@@ -389,7 +389,7 @@ impl WatchClient {
                 );
 
                 // rebuild run struct
-                self.run = RunBuilder::new(base.clone())?
+                self.run = RunBuilder::new(base.clone(), None)?
                     .hide_prelude()
                     .build(&self.handler, self.telemetry.clone())
                     .await?