chore(Turborepo): Move daemon paths off of CommandBase (#7339)

### Description

Stepping stone to moving `CommandBase` out of `run` 
- Move daemon path handling into the daemon module

### Testing Instructions

Updated existing test suite


Closes TURBO-2323

---------

Co-authored-by: Greg Soltis <Greg Soltis>

Author: Greg Soltis

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

@@ -7,7 +7,7 @@ use serde_json::json;
 use time::{format_description, OffsetDateTime};
 use tokio::signal::ctrl_c;
 use tracing::{trace, warn};
-use turbopath::{AbsoluteSystemPath, AbsoluteSystemPathBuf};
+use turbopath::AbsoluteSystemPath;
 use turborepo_ui::{color, BOLD_GREEN, BOLD_RED, GREY};
 use which::which;
 
@@ -16,6 +16,7 @@ use crate::{
     cli::DaemonCommand,
     daemon::{
         endpoint::SocketOpenError, CloseReason, DaemonConnector, DaemonConnectorError, DaemonError,
+        Paths,
     },
     tracing::TurboSubscriber,
 };
@@ -32,15 +33,7 @@ pub async fn daemon_client(command: &DaemonCommand, base: &CommandBase) -> Resul
         DaemonCommand::Clean => (false, true),
     };
 
-    let pid_file = base.daemon_file_root().join_component("turbod.pid");
-    let sock_file = base.daemon_file_root().join_component("turbod.sock");
-
-    let connector = DaemonConnector {
-        can_start_server,
-        can_kill_server,
-        pid_file: pid_file.clone(),
-        sock_file: sock_file.clone(),
-    };
+    let connector = DaemonConnector::new(can_start_server, can_kill_server, &base.repo_root);
 
     match command {
         DaemonCommand::Restart => {
@@ -52,7 +45,7 @@ pub async fn daemon_client(command: &DaemonCommand, base: &CommandBase) -> Resul
             if let Err(e) = result {
                 tracing::debug!("failed to restart the daemon: {:?}", e);
                 tracing::debug!("falling back to clean");
-                clean(&pid_file, &sock_file).await?;
+                clean(&connector.paths.pid_file, &connector.paths.sock_file).await?;
                 tracing::debug!("connecting for second time");
                 let _ = connector.connect().await?;
             }
@@ -100,11 +93,12 @@ pub async fn daemon_client(command: &DaemonCommand, base: &CommandBase) -> Resul
             };
             let status = client.status().await?;
             let log_file = log_filename(&status.log_file)?;
+            let paths = client.paths();
             let status = DaemonStatus {
                 uptime_ms: status.uptime_msec,
                 log_file: log_file.into(),
-                pid_file: client.pid_file().to_owned(),
-                sock_file: client.sock_file().to_owned(),
+                pid_file: paths.pid_file.to_owned(),
+                sock_file: paths.sock_file.to_owned(),
             };
 
             if *json {
@@ -141,6 +135,7 @@ pub async fn daemon_client(command: &DaemonCommand, base: &CommandBase) -> Resul
         }
         DaemonCommand::Clean => {
             // try to connect and shutdown the daemon
+            let paths = connector.paths.clone();
             let client = connector.connect().await;
             match client {
                 Ok(client) => match client.stop().await {
@@ -155,7 +150,7 @@ pub async fn daemon_client(command: &DaemonCommand, base: &CommandBase) -> Resul
                     tracing::trace!("unable to connect to the daemon: {:?}", e);
                 }
             }
-            clean(&pid_file, &sock_file).await?;
+            clean(&paths.pid_file, &paths.sock_file).await?;
             println!("Done");
         }
     };
@@ -214,25 +209,12 @@ pub async fn daemon_server(
     idle_time: &String,
     logging: &TurboSubscriber,
 ) -> Result<(), DaemonError> {
-    let (log_folder, log_file) = {
-        let directories = directories::ProjectDirs::from("com", "turborepo", "turborepo")
-            .expect("user has a home dir");
-
-        let folder =
-            AbsoluteSystemPathBuf::new(directories.data_dir().to_str().expect("UTF-8 path"))
-                .expect("absolute");
-
-        let log_folder = folder.join_component("logs");
-        let log_file =
-            log_folder.join_component(format!("{}-turbo.log", base.repo_hash()).as_str());
-
-        (log_folder, log_file)
-    };
+    let paths = Paths::from_repo_root(&base.repo_root);
 
-    tracing::trace!("logging to file: {:?}", log_file);
+    tracing::trace!("logging to file: {:?}", paths.log_file);
     if let Err(e) = logging.set_daemon_logger(tracing_appender::rolling::daily(
-        log_folder,
-        log_file.clone(),
+        &paths.log_folder,
+        &paths.log_file,
     )) {
         // error here is not fatal, just log it
         tracing::error!("failed to set file logger: {}", e);
@@ -242,20 +224,14 @@ pub async fn daemon_server(
         .map_err(|_| DaemonError::InvalidTimeout(idle_time.to_owned()))
         .map(|d| Duration::from_nanos(d as u64))?;
 
-    let daemon_root = base.daemon_file_root();
     let exit_signal = ctrl_c().map(|result| {
         if let Err(e) = result {
             tracing::error!("Error with signal handling: {}", e);
         }
         CloseReason::Interrupt
     });
-    let server = crate::daemon::TurboGrpcService::new(
-        base.repo_root.clone(),
-        daemon_root,
-        log_file,
-        timeout,
-        exit_signal,
-    );
+    let server =
+        crate::daemon::TurboGrpcService::new(base.repo_root.clone(), paths, timeout, exit_signal);
 
     let reason = server.serve().await?;
 

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

@@ -1,7 +1,6 @@
 use std::cell::OnceCell;
 
 use dirs_next::config_dir;
-use sha2::{Digest, Sha256};
 use turbopath::{AbsoluteSystemPath, AbsoluteSystemPathBuf};
 use turborepo_api_client::{APIAuth, APIClient};
 use turborepo_ui::UI;
@@ -134,89 +133,7 @@ impl CommandBase {
         &self.repo_root
     }
 
-    pub fn daemon_file_root(&self) -> AbsoluteSystemPathBuf {
-        DaemonRootHasher(&self.repo_root).daemon_file_root()
-    }
-
-    fn repo_hash(&self) -> String {
-        DaemonRootHasher(&self.repo_root).repo_hash()
-    }
-
     pub fn version(&self) -> &'static str {
         self.version
     }
 }
-
-pub struct DaemonRootHasher<'a>(&'a AbsoluteSystemPath);
-
-impl<'a> DaemonRootHasher<'a> {
-    pub fn new(repo_root: &'a AbsoluteSystemPath) -> Self {
-        Self(repo_root)
-    }
-
-    pub fn daemon_file_root(&self) -> AbsoluteSystemPathBuf {
-        AbsoluteSystemPathBuf::new(std::env::temp_dir().to_str().expect("UTF-8 path"))
-            .expect("temp dir is valid")
-            .join_component("turbod")
-            .join_component(self.repo_hash().as_str())
-    }
-
-    pub fn sock_path(&self) -> AbsoluteSystemPathBuf {
-        self.daemon_file_root().join_component("turbod.sock")
-    }
-
-    pub fn lock_path(&self) -> AbsoluteSystemPathBuf {
-        self.daemon_file_root().join_component("turbod.pid")
-    }
-
-    pub fn lsp_path(&self) -> AbsoluteSystemPathBuf {
-        self.daemon_file_root().join_component("lsp.pid")
-    }
-
-    fn repo_hash(&self) -> String {
-        let mut hasher = Sha256::new();
-        hasher.update(self.0.as_bytes());
-        hex::encode(&hasher.finalize()[..8])
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use test_case::test_case;
-    use turbopath::AbsoluteSystemPathBuf;
-    use turborepo_ui::UI;
-
-    use crate::get_version;
-
-    #[cfg(not(target_os = "windows"))]
-    #[test_case("/tmp/turborepo", "6e0cfa616f75a61c"; "basic example")]
-    fn test_repo_hash(path: &str, expected_hash: &str) {
-        use super::CommandBase;
-        use crate::Args;
-
-        let args = Args::default();
-        let repo_root = AbsoluteSystemPathBuf::new(path).unwrap();
-        let command_base = CommandBase::new(args, repo_root, get_version(), UI::new(true));
-
-        let hash = command_base.repo_hash();
-
-        assert_eq!(hash, expected_hash);
-        assert_eq!(hash.len(), 16);
-    }
-
-    #[cfg(target_os = "windows")]
-    #[test_case("C:\\\\tmp\\turborepo", "0103736e6883e35f"; "basic example")]
-    fn test_repo_hash_win(path: &str, expected_hash: &str) {
-        use super::CommandBase;
-        use crate::Args;
-
-        let args = Args::default();
-        let repo_root = AbsoluteSystemPathBuf::new(path).unwrap();
-        let command_base = CommandBase::new(args, repo_root, get_version(), UI::new(true));
-
-        let hash = command_base.repo_hash();
-
-        assert_eq!(hash, expected_hash);
-        assert_eq!(hash.len(), 16);
-    }
-}

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

@@ -10,6 +10,7 @@ use super::{
     connector::{DaemonConnector, DaemonConnectorError},
     endpoint::SocketOpenError,
     proto::DiscoverPackagesResponse,
+    Paths,
 };
 use crate::{daemon::proto, globwatcher::HashGlobSetupError};
 
@@ -140,12 +141,8 @@ impl DaemonClient<DaemonConnector> {
         self.stop().await?.connect().await.map_err(Into::into)
     }
 
-    pub fn pid_file(&self) -> &turbopath::AbsoluteSystemPathBuf {
-        &self.connect_settings.pid_file
-    }
-
-    pub fn sock_file(&self) -> &turbopath::AbsoluteSystemPathBuf {
-        &self.connect_settings.sock_file
+    pub fn paths(&self) -> &Paths {
+        &self.connect_settings.paths
     }
 }
 

crates/turborepo-lib/src/daemon/connector.rs

@@ -13,8 +13,9 @@ use thiserror::Error;
 use tokio::{sync::mpsc, time::timeout};
 use tonic::transport::Endpoint;
 use tracing::debug;
+use turbopath::AbsoluteSystemPath;
 
-use super::{proto::turbod_client::TurbodClient, DaemonClient};
+use super::{proto::turbod_client::TurbodClient, DaemonClient, Paths};
 use crate::daemon::DaemonError;
 
 #[derive(Error, Debug)]
@@ -64,11 +65,23 @@ pub struct DaemonConnector {
     /// Whether the connector is allowed to kill a running daemon (for example,
     /// in the event of a version mismatch).
     pub can_kill_server: bool,
-    pub pid_file: turbopath::AbsoluteSystemPathBuf,
-    pub sock_file: turbopath::AbsoluteSystemPathBuf,
+    pub paths: Paths,
 }
 
 impl DaemonConnector {
+    pub fn new(
+        can_start_server: bool,
+        can_kill_server: bool,
+        repo_root: &AbsoluteSystemPath,
+    ) -> Self {
+        let paths = Paths::from_repo_root(repo_root);
+        Self {
+            can_start_server,
+            can_kill_server,
+            paths,
+        }
+    }
+
     const CONNECT_RETRY_MAX: usize = 3;
     const CONNECT_TIMEOUT: Duration = Duration::from_secs(1);
     const SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(1);
@@ -93,7 +106,7 @@ impl DaemonConnector {
             let pid = self.get_or_start_daemon().await?;
             debug!("got daemon with pid: {}", pid);
 
-            let conn = match self.get_connection(self.sock_file.clone()).await {
+            let conn = match self.get_connection(self.paths.sock_file.clone()).await {
                 Err(DaemonConnectorError::Watcher(_)) => continue,
                 Err(DaemonConnectorError::Socket(e)) => {
                     // assume the server is not yet ready
@@ -130,7 +143,7 @@ impl DaemonConnector {
     ///
     /// If a daemon is not running, it starts one.
     async fn get_or_start_daemon(&self) -> Result<sysinfo::Pid, DaemonConnectorError> {
-        debug!("looking for pid in lockfile: {:?}", self.pid_file);
+        debug!("looking for pid in lockfile: {:?}", self.paths.pid_file);
 
         let pidfile = self.pid_lock();
 
@@ -225,7 +238,7 @@ impl DaemonConnector {
 
         match timeout(
             Self::SHUTDOWN_TIMEOUT,
-            wait_for_file(&self.pid_file, WaitAction::Deleted),
+            wait_for_file(&self.paths.pid_file, WaitAction::Deleted),
         )
         .await?
         {
@@ -273,19 +286,19 @@ impl DaemonConnector {
         // exists to protect against stale .sock files
         timeout(
             Self::SOCKET_TIMEOUT,
-            wait_for_file(&self.pid_file, WaitAction::Exists),
+            wait_for_file(&self.paths.pid_file, WaitAction::Exists),
         )
         .await??;
         timeout(
             Self::SOCKET_TIMEOUT,
-            wait_for_file(&self.sock_file, WaitAction::Exists),
+            wait_for_file(&self.paths.sock_file, WaitAction::Exists),
         )
         .await?
         .map_err(Into::into)
     }
 
     fn pid_lock(&self) -> pidlock::Pidlock {
-        pidlock::Pidlock::new(self.pid_file.clone().into())
+        pidlock::Pidlock::new(self.paths.pid_file.clone().into())
     }
 }
 
@@ -396,7 +409,7 @@ enum WaitAction {
 
 #[cfg(test)]
 mod test {
-    use std::{assert_matches::assert_matches, path::Path};
+    use std::assert_matches::assert_matches;
 
     use sysinfo::Pid;
     use tokio::{
@@ -414,28 +427,18 @@ mod test {
     #[cfg(target_os = "windows")]
     const NODE_EXE: &str = "node.exe";
 
-    fn pid_path(tmp_path: &Path) -> AbsoluteSystemPathBuf {
-        AbsoluteSystemPathBuf::try_from(tmp_path.join("turbod.pid")).unwrap()
-    }
-
-    fn sock_path(tmp_path: &Path) -> AbsoluteSystemPathBuf {
-        AbsoluteSystemPathBuf::try_from(tmp_path.join("turbod.sock")).unwrap()
-    }
-
     #[tokio::test]
     async fn handles_invalid_pid() {
         let tmp_dir = tempfile::tempdir().unwrap();
-        let tmp_path = tmp_dir.path().to_owned();
-
-        let pid = pid_path(&tmp_path);
-        std::fs::write(&pid, "not a pid").unwrap();
-
-        let connector = DaemonConnector {
-            pid_file: pid,
-            sock_file: sock_path(&tmp_path),
-            can_kill_server: false,
-            can_start_server: false,
-        };
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+
+        let connector = DaemonConnector::new(false, false, &repo_root);
+        connector.paths.pid_file.ensure_dir().unwrap();
+        connector
+            .paths
+            .pid_file
+            .create_with_contents("not a pid")
+            .unwrap();
 
         assert_matches!(
             connector.get_or_start_daemon().await,
@@ -446,17 +449,8 @@ mod test {
     #[tokio::test]
     async fn handles_missing_server_connect() {
         let tmp_dir = tempfile::tempdir().unwrap();
-        let tmp_path = tmp_dir.path().to_owned();
-
-        let pid = pid_path(&tmp_path);
-        let sock = sock_path(&tmp_path);
-
-        let connector = DaemonConnector {
-            pid_file: pid,
-            sock_file: sock,
-            can_kill_server: false,
-            can_start_server: false,
-        };
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+        let connector = DaemonConnector::new(false, false, &repo_root);
 
         assert_matches!(
             connector.connect().await,
@@ -467,17 +461,8 @@ mod test {
     #[tokio::test]
     async fn handles_kill_dead_server_missing_pid() {
         let tmp_dir = tempfile::tempdir().unwrap();
-        let tmp_path = tmp_dir.path().to_owned();
-
-        let pid = pid_path(&tmp_path);
-        let sock = sock_path(&tmp_path);
-
-        let connector = DaemonConnector {
-            pid_file: pid,
-            sock_file: sock,
-            can_kill_server: false,
-            can_start_server: false,
-        };
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+        let connector = DaemonConnector::new(false, false, &repo_root);
 
         assert_matches!(
             connector.kill_dead_server(Pid::from(usize::MAX)).await,
@@ -488,35 +473,34 @@ mod test {
     #[tokio::test]
     async fn handles_kill_dead_server_missing_process() {
         let tmp_dir = tempfile::tempdir().unwrap();
-        let tmp_path = tmp_dir.path().to_owned();
-
-        let pid = pid_path(&tmp_path);
-        std::fs::write(&pid, i32::MAX.to_string()).unwrap();
-        let sock = sock_path(&tmp_path);
-        std::fs::write(&sock, "").unwrap();
-
-        let connector = DaemonConnector {
-            pid_file: pid,
-            sock_file: sock,
-            can_kill_server: false,
-            can_start_server: false,
-        };
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+        let connector = DaemonConnector::new(false, false, &repo_root);
+
+        connector.paths.pid_file.ensure_dir().unwrap();
+        connector
+            .paths
+            .pid_file
+            .create_with_contents(i32::MAX.to_string())
+            .unwrap();
+        connector.paths.sock_file.ensure_dir().unwrap();
+        connector.paths.sock_file.create_with_contents("").unwrap();
 
         assert_matches!(
             connector.kill_dead_server(Pid::from(usize::MAX)).await,
             Ok(())
         );
 
         assert!(
-            !connector.pid_file.exists(),
+            !connector.paths.pid_file.exists(),
             "pid file should be cleaned up when getting the owner of a stale pid"
         );
     }
 
     #[tokio::test]
     async fn handles_kill_dead_server_wrong_process() {
         let tmp_dir = tempfile::tempdir().unwrap();
-        let tmp_path = tmp_dir.path().to_owned();
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+        let connector = DaemonConnector::new(false, false, &repo_root);
 
         let proc = tokio::process::Command::new(NODE_EXE)
             .stdout(Stdio::null())
@@ -526,17 +510,14 @@ mod test {
             .spawn()
             .unwrap();
 
-        let pid = pid_path(&tmp_path);
-        std::fs::write(&pid, proc.id().unwrap().to_string()).unwrap();
-        let sock = sock_path(&tmp_path);
-        std::fs::write(&sock, "").unwrap();
-
-        let connector = DaemonConnector {
-            pid_file: pid,
-            sock_file: sock,
-            can_kill_server: true,
-            can_start_server: false,
-        };
+        connector.paths.pid_file.ensure_dir().unwrap();
+        connector
+            .paths
+            .pid_file
+            .create_with_contents(proc.id().unwrap().to_string())
+            .unwrap();
+        connector.paths.sock_file.ensure_dir().unwrap();
+        connector.paths.sock_file.create_with_contents("").unwrap();
 
         let kill_pid = Pid::from(usize::MAX);
         let proc_id = Pid::from(proc.id().unwrap() as usize);
@@ -546,13 +527,17 @@ mod test {
             Err(DaemonConnectorError::WrongPidProcess(daemon, running)) if daemon == kill_pid && running == proc_id
         );
 
-        assert!(connector.pid_file.exists(), "pid file should still exist");
+        assert!(
+            connector.paths.pid_file.exists(),
+            "pid file should still exist"
+        );
     }
 
     #[tokio::test]
     async fn handles_kill_dead_server() {
         let tmp_dir = tempfile::tempdir().unwrap();
-        let tmp_path = tmp_dir.path().to_owned();
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+        let connector = DaemonConnector::new(false, true, &repo_root);
 
         let proc = tokio::process::Command::new(NODE_EXE)
             .stdout(Stdio::null())
@@ -562,17 +547,14 @@ mod test {
             .spawn()
             .unwrap();
 
-        let pid = pid_path(&tmp_path);
-        std::fs::write(&pid, proc.id().unwrap().to_string()).unwrap();
-        let sock = sock_path(&tmp_path);
-        std::fs::write(&sock, "").unwrap();
-
-        let connector = DaemonConnector {
-            pid_file: pid,
-            sock_file: sock,
-            can_kill_server: true,
-            can_start_server: false,
-        };
+        connector.paths.pid_file.ensure_dir().unwrap();
+        connector
+            .paths
+            .pid_file
+            .create_with_contents(proc.id().unwrap().to_string())
+            .unwrap();
+        connector.paths.sock_file.ensure_dir().unwrap();
+        connector.paths.sock_file.create_with_contents("").unwrap();
 
         assert_matches!(
             connector
@@ -581,7 +563,10 @@ mod test {
             Ok(())
         );
 
-        assert!(connector.pid_file.exists(), "pid file should still exist");
+        assert!(
+            connector.paths.pid_file.exists(),
+            "pid file should still exist"
+        );
     }
 
     struct DummyServer {
@@ -664,25 +649,9 @@ mod test {
             }))
             .serve_with_incoming(stream);
 
-        let (pid_file, sock_file) = if cfg!(windows) {
-            (
-                AbsoluteSystemPathBuf::new("C:\\pid").unwrap(),
-                AbsoluteSystemPathBuf::new("C:\\sock").unwrap(),
-            )
-        } else {
-            (
-                AbsoluteSystemPathBuf::new("/pid").unwrap(),
-                AbsoluteSystemPathBuf::new("/sock").unwrap(),
-            )
-        };
-
-        // set up the client
-        let conn = DaemonConnector {
-            pid_file,
-            sock_file,
-            can_kill_server: false,
-            can_start_server: false,
-        };
+        let tmp_dir = tempfile::tempdir().unwrap();
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+        let connector = DaemonConnector::new(false, false, &repo_root);
 
         let mut client = Endpoint::try_from("http://[::]:50051")
             .expect("this is a valid uri")
@@ -716,7 +685,7 @@ mod test {
         assert_matches!(hello_resp, DaemonError::VersionMismatch(_));
         let client = DaemonClient::new(client);
 
-        let shutdown_fut = conn.kill_live_server(client, Pid::from(1000));
+        let shutdown_fut = connector.kill_live_server(client, Pid::from(1000));
 
         // drive the futures to completion
         select! {

crates/turborepo-lib/src/daemon/endpoint.rs

@@ -30,7 +30,8 @@ const WINDOWS_POLL_DURATION: Duration = Duration::from_millis(1);
 ///       code path to shut down the non-blocking polling
 #[tracing::instrument]
 pub async fn listen_socket(
-    daemon_root: &AbsoluteSystemPath,
+    pid_path: &AbsoluteSystemPath,
+    sock_path: &AbsoluteSystemPath,
     #[allow(unused)] running: Arc<AtomicBool>,
 ) -> Result<
     (
@@ -39,8 +40,6 @@ pub async fn listen_socket(
     ),
     SocketOpenError,
 > {
-    let pid_path = daemon_root.join_component("turbod.pid");
-    let sock_path = daemon_root.join_component("turbod.sock");
     let mut lock = pidlock::Pidlock::new(pid_path.as_std_path().to_owned());
 
     trace!("acquiring pidlock");
@@ -186,7 +185,7 @@ mod test {
     use turbopath::{AbsoluteSystemPath, AbsoluteSystemPathBuf};
 
     use super::listen_socket;
-    use crate::daemon::endpoint::SocketOpenError;
+    use crate::daemon::{endpoint::SocketOpenError, Paths};
 
     fn pid_path(daemon_root: &AbsoluteSystemPath) -> AbsoluteSystemPathBuf {
         daemon_root.join_component("turbod.pid")
@@ -195,13 +194,14 @@ mod test {
     #[tokio::test]
     async fn test_stale_pid() {
         let tmp_dir = tempfile::tempdir().unwrap();
-        let daemon_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
-        let pid_path = pid_path(&daemon_root);
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+        let paths = Paths::from_repo_root(&repo_root);
+        paths.pid_file.ensure_dir().unwrap();
         // A pid that will never be running and is guaranteed not to be us
-        pid_path.create_with_contents("100000").unwrap();
+        paths.pid_file.create_with_contents("100000").unwrap();
 
         let running = Arc::new(AtomicBool::new(true));
-        let result = listen_socket(&daemon_root, running).await;
+        let result = listen_socket(&paths.pid_file, &paths.sock_file, running).await;
 
         assert!(
             result.is_ok(),
@@ -212,21 +212,23 @@ mod test {
     #[tokio::test]
     async fn test_existing_process() {
         let tmp_dir = tempfile::tempdir().unwrap();
-        let daemon_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
-        let pid_path = pid_path(&daemon_root);
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+        let paths = Paths::from_repo_root(&repo_root);
 
         #[cfg(windows)]
         let node_bin = "node.exe";
         #[cfg(not(windows))]
         let node_bin = "node";
 
         let mut child = Command::new(node_bin).spawn().unwrap();
-        pid_path
+        paths.pid_file.ensure_dir().unwrap();
+        paths
+            .pid_file
             .create_with_contents(format!("{}", child.id()))
             .unwrap();
 
         let running = Arc::new(AtomicBool::new(true));
-        let result = listen_socket(&daemon_root, running).await;
+        let result = listen_socket(&paths.pid_file, &paths.sock_file, running).await;
 
         // Note: PidLock doesn't implement Debug, so we can't unwrap_err()
 

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

@@ -8,6 +8,60 @@ mod server;
 pub use client::{DaemonClient, DaemonError};
 pub use connector::{DaemonConnector, DaemonConnectorError};
 pub use server::{CloseReason, TurboGrpcService};
+use sha2::{Digest, Sha256};
+use turbopath::{AbsoluteSystemPath, AbsoluteSystemPathBuf};
+
+#[derive(Clone, Debug)]
+pub struct Paths {
+    pub pid_file: AbsoluteSystemPathBuf,
+    pub lock_file: AbsoluteSystemPathBuf,
+    pub sock_file: AbsoluteSystemPathBuf,
+    pub lsp_pid_file: AbsoluteSystemPathBuf,
+    pub log_file: AbsoluteSystemPathBuf,
+    pub log_folder: AbsoluteSystemPathBuf,
+}
+
+fn repo_hash(repo_root: &AbsoluteSystemPath) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(repo_root.to_string().as_bytes());
+    hex::encode(&hasher.finalize()[..8])
+}
+
+fn daemon_file_root(repo_hash: &str) -> AbsoluteSystemPathBuf {
+    AbsoluteSystemPathBuf::new(std::env::temp_dir().to_str().expect("UTF-8 path"))
+        .expect("temp dir is valid")
+        .join_component("turbod")
+        .join_component(repo_hash)
+}
+
+fn daemon_log_file_and_folder(repo_hash: &str) -> (AbsoluteSystemPathBuf, AbsoluteSystemPathBuf) {
+    let directories = directories::ProjectDirs::from("com", "turborepo", "turborepo")
+        .expect("user has a home dir");
+
+    let folder = AbsoluteSystemPathBuf::new(directories.data_dir().to_str().expect("UTF-8 path"))
+        .expect("absolute");
+
+    let log_folder = folder.join_component("logs");
+    let log_file = log_folder.join_component(format!("{}-turbo.log", repo_hash).as_str());
+
+    (log_file, log_folder)
+}
+
+impl Paths {
+    pub fn from_repo_root(repo_root: &AbsoluteSystemPath) -> Self {
+        let repo_hash = repo_hash(repo_root);
+        let daemon_root = daemon_file_root(&repo_hash);
+        let (log_file, log_folder) = daemon_log_file_and_folder(&repo_hash);
+        Self {
+            pid_file: daemon_root.join_component("turbod.pid"),
+            lock_file: daemon_root.join_component("turbod.lock"),
+            sock_file: daemon_root.join_component("turbod.sock"),
+            lsp_pid_file: daemon_root.join_component("lsp.pid"),
+            log_file,
+            log_folder,
+        }
+    }
+}
 
 pub(crate) mod proto {
 
@@ -54,3 +108,23 @@ pub(crate) mod proto {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use turbopath::AbsoluteSystemPathBuf;
+
+    use super::repo_hash;
+
+    #[test]
+    fn test_repo_hash() {
+        #[cfg(not(target_os = "windows"))]
+        let (path, expected_hash) = ("/tmp/turborepo", "6e0cfa616f75a61c");
+        #[cfg(target_os = "windows")]
+        let (path, expected_hash) = ("C:\\\\tmp\\turborepo", "0103736e6883e35f");
+        let repo_root = AbsoluteSystemPathBuf::new(path).unwrap();
+        let hash = repo_hash(&repo_root);
+
+        assert_eq!(hash, expected_hash);
+        assert_eq!(hash.len(), 16);
+    }
+}

crates/turborepo-lib/src/daemon/server.rs

@@ -42,11 +42,7 @@ use turborepo_repository::discovery::{
     DiscoveryResponse, LocalPackageDiscoveryBuilder, PackageDiscovery, PackageDiscoveryBuilder,
 };
 
-use super::{
-    bump_timeout::BumpTimeout,
-    endpoint::SocketOpenError,
-    proto::{self},
-};
+use super::{bump_timeout::BumpTimeout, endpoint::SocketOpenError, proto, Paths};
 use crate::daemon::{bump_timeout_layer::BumpTimeoutLayer, endpoint::listen_socket};
 
 #[derive(Debug)]
@@ -120,8 +116,7 @@ pub struct TurboGrpcService<S, PDB> {
     watcher_tx: watch::Sender<Option<Arc<FileWatching>>>,
     watcher_rx: watch::Receiver<Option<Arc<FileWatching>>>,
     repo_root: AbsoluteSystemPathBuf,
-    daemon_root: AbsoluteSystemPathBuf,
-    log_file: AbsoluteSystemPathBuf,
+    paths: Paths,
     timeout: Duration,
     external_shutdown: S,
 
@@ -140,8 +135,7 @@ where
     /// state if the filewatcher encounters errors.
     pub fn new(
         repo_root: AbsoluteSystemPathBuf,
-        daemon_root: AbsoluteSystemPathBuf,
-        log_file: AbsoluteSystemPathBuf,
+        paths: Paths,
         timeout: Duration,
         external_shutdown: S,
     ) -> Self {
@@ -157,8 +151,7 @@ where
             watcher_tx,
             watcher_rx,
             repo_root,
-            daemon_root,
-            log_file,
+            paths,
             timeout,
             external_shutdown,
             package_discovery_backup,
@@ -179,9 +172,8 @@ where
         package_discovery_backup: PDB2,
     ) -> TurboGrpcService<S, PDB2> {
         TurboGrpcService {
-            daemon_root: self.daemon_root,
             external_shutdown: self.external_shutdown,
-            log_file: self.log_file,
+            paths: self.paths,
             repo_root: self.repo_root,
             timeout: self.timeout,
             watcher_rx: self.watcher_rx,
@@ -194,19 +186,19 @@ where
         let Self {
             watcher_tx,
             watcher_rx,
-            daemon_root,
             external_shutdown,
-            log_file,
+            paths,
             repo_root,
             timeout,
             package_discovery_backup,
         } = self;
 
         let running = Arc::new(AtomicBool::new(true));
-        let (_pid_lock, stream) = match listen_socket(&daemon_root, running.clone()).await {
-            Ok((pid_lock, stream)) => (pid_lock, stream),
-            Err(e) => return Ok(CloseReason::SocketOpenError(e)),
-        };
+        let (_pid_lock, stream) =
+            match listen_socket(&paths.pid_file, &paths.sock_file, running.clone()).await {
+                Ok((pid_lock, stream)) => (pid_lock, stream),
+                Err(e) => return Ok(CloseReason::SocketOpenError(e)),
+            };
         trace!("acquired connection stream for socket");
 
         let watcher_repo_root = repo_root.to_owned();
@@ -261,7 +253,7 @@ where
             watcher_rx,
             times_saved: Arc::new(Mutex::new(HashMap::new())),
             start_time: Instant::now(),
-            log_file: log_file.to_owned(),
+            log_file: paths.log_file.clone(),
         };
         let server_fut = {
             let service = ServiceBuilder::new()
@@ -567,7 +559,7 @@ mod test {
     };
 
     use super::compare_versions;
-    use crate::daemon::{proto::VersionRange, CloseReason, TurboGrpcService};
+    use crate::daemon::{proto::VersionRange, CloseReason, Paths, TurboGrpcService};
 
     #[test_case("1.2.3", "1.2.3", VersionRange::Exact, true ; "exact match")]
     #[test_case("1.2.3", "1.2.3", VersionRange::Patch, true ; "patch match")]
@@ -623,19 +615,15 @@ mod test {
             .unwrap();
 
         let repo_root = path.join_component("repo");
-        let daemon_root = path.join_component("daemon");
-        let log_file = daemon_root.join_component("log");
+        let paths = Paths::from_repo_root(&repo_root);
         tracing::info!("start");
 
-        let pid_path = daemon_root.join_component("turbod.pid");
-
         let (tx, rx) = oneshot::channel::<CloseReason>();
         let exit_signal = rx.map(|_result| CloseReason::Interrupt);
 
         let service = TurboGrpcService::new(
             repo_root.clone(),
-            daemon_root,
-            log_file,
+            paths.clone(),
             Duration::from_secs(60 * 60),
             exit_signal,
         )
@@ -651,9 +639,9 @@ mod test {
 
         tokio::time::sleep(Duration::from_millis(2000)).await;
         assert!(
-            pid_path.exists(),
+            paths.pid_file.exists(),
             "pid file must be present at {:?}",
-            pid_path
+            paths.pid_file
         );
         // signal server exit
         tx.send(CloseReason::Interrupt).unwrap();
@@ -662,7 +650,7 @@ mod test {
         // The serve future should be dropped here, closing the server.
         tracing::info!("yay we are done");
 
-        assert!(!pid_path.exists(), "pid file must be deleted");
+        assert!(!paths.pid_file.exists(), "pid file must be deleted");
 
         tracing::info!("and files cleaned up");
     }
@@ -679,19 +667,15 @@ mod test {
             .unwrap();
 
         let repo_root = path.join_component("repo");
-        let daemon_root = path.join_component("daemon");
-        let log_file = daemon_root.join_component("log");
-
-        let pid_path = daemon_root.join_component("turbod.pid");
+        let paths = Paths::from_repo_root(&repo_root);
 
         let now = Instant::now();
         let (_tx, rx) = oneshot::channel::<CloseReason>();
         let exit_signal = rx.map(|_result| CloseReason::Interrupt);
 
         let server = TurboGrpcService::new(
             repo_root.clone(),
-            daemon_root,
-            log_file,
+            paths.clone(),
             Duration::from_millis(10),
             exit_signal,
         )
@@ -714,7 +698,7 @@ mod test {
             Ok(CloseReason::Timeout),
             "must close due to timeout"
         );
-        assert!(!pid_path.exists(), "pid file must be deleted");
+        assert!(!paths.pid_file.exists(), "pid file must be deleted");
     }
 
     #[tokio::test(flavor = "multi_thread")]
@@ -727,17 +711,14 @@ mod test {
             .unwrap();
 
         let repo_root = path.join_component("repo");
-        let daemon_root = path.join_component("daemon");
-        daemon_root.create_dir_all().unwrap();
-        let log_file = daemon_root.join_component("log");
+        let paths = Paths::from_repo_root(&repo_root);
 
         let (_tx, rx) = oneshot::channel::<CloseReason>();
         let exit_signal = rx.map(|_result| CloseReason::Interrupt);
 
         let server = TurboGrpcService::new(
             repo_root.clone(),
-            daemon_root,
-            log_file,
+            paths,
             Duration::from_secs(60 * 60),
             exit_signal,
         )

crates/turborepo-lib/src/lib.rs

@@ -37,8 +37,7 @@ mod unescape;
 pub use crate::{
     child::spawn_child,
     cli::Args,
-    commands::DaemonRootHasher,
-    daemon::{DaemonClient, DaemonConnector},
+    daemon::{DaemonClient, DaemonConnector, Paths as DaemonPaths},
     run::package_discovery::DaemonPackageDiscovery,
 };
 

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

@@ -249,13 +249,10 @@ impl Run {
                 None
             }
             (_, Some(true)) | (false, None) => {
-                let connector = DaemonConnector {
-                    can_start_server: true,
-                    can_kill_server: true,
-                    pid_file: self.base.daemon_file_root().join_component("turbod.pid"),
-                    sock_file: self.base.daemon_file_root().join_component("turbod.sock"),
-                };
-
+                let can_start_server = true;
+                let can_kill_server = true;
+                let connector =
+                    DaemonConnector::new(can_start_server, can_kill_server, &self.base.repo_root);
                 match (connector.connect().await, self.opts.run_opts.daemon) {
                     (Ok(client), _) => {
                         run_telemetry.track_daemon_init(DaemonInitStatus::Started);

crates/turborepo-lsp/src/lib.rs

@@ -18,7 +18,7 @@ use tower_lsp::{
     Client, LanguageServer,
 };
 use turbopath::AbsoluteSystemPathBuf;
-use turborepo_lib::{DaemonClient, DaemonConnector, DaemonPackageDiscovery, DaemonRootHasher};
+use turborepo_lib::{DaemonClient, DaemonConnector, DaemonPackageDiscovery, DaemonPaths};
 use turborepo_repository::{
     discovery::{self, DiscoveryResponse, PackageDiscovery},
     package_json::PackageJson,
@@ -60,22 +60,18 @@ impl LanguageServer for Backend {
                 .expect("only fails if poisoned")
                 .replace(repo_root.clone());
 
-            let hasher = DaemonRootHasher::new(&repo_root);
+            let paths = DaemonPaths::from_repo_root(&repo_root);
 
             let (_, daemon) = tokio::join!(
-                self.client.log_message(
-                    MessageType::INFO,
-                    format!("root uri: {}", hasher.sock_path()),
-                ),
+                self.client
+                    .log_message(MessageType::INFO, format!("root uri: {}", paths.sock_file),),
                 tokio_retry::Retry::spawn(
                     tokio_retry::strategy::FixedInterval::from_millis(100).take(5),
                     || {
-                        let connector = DaemonConnector {
-                            can_start_server: true,
-                            can_kill_server: false,
-                            pid_file: hasher.lock_path(),
-                            sock_file: hasher.sock_path(),
-                        };
+                        let can_start_server = true;
+                        let can_kill_server = false;
+                        let connector =
+                            DaemonConnector::new(can_start_server, can_kill_server, &repo_root);
                         connector.connect()
                     },
                 )
@@ -98,7 +94,7 @@ impl LanguageServer for Backend {
                 .send(Some(daemon))
                 .expect("there is a receiver");
 
-            let mut lock = pidlock::Pidlock::new(hasher.lsp_path().as_std_path().to_owned());
+            let mut lock = pidlock::Pidlock::new(paths.lsp_pid_file.as_std_path().to_owned());
 
             if let Err(e) = lock.acquire() {
                 self.client

packages/turbo-repository/npm/linux-x64-musl/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@turbo/repository-linux-x64-musl",
+  "version": "0.0.1-canary.5",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vercel/turbo",
+    "directory": "packages/turbo-repository/npm/linux-x64-musl"
+  },
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "libc": [
+    "musl"
+  ],
+  "main": "repository.linux-x64-musl.node",
+  "files": [
+    "repository.linux-x64-musl.node"
+  ],
+  "license": "MPL-2.0",
+  "engines": {
+    "node": ">= 10"
+  }
+}