1use futures::{FutureExt, future::Shared};
2use language::Buffer;
3use std::{path::Path, sync::Arc};
4use util::ResultExt;
5use worktree::Worktree;
6
7use collections::HashMap;
8use gpui::{AppContext as _, Context, Entity, EventEmitter, Task};
9use settings::Settings as _;
10
11use crate::{
12 project_settings::{DirenvSettings, ProjectSettings},
13 worktree_store::WorktreeStore,
14};
15
16pub struct ProjectEnvironment {
17 cli_environment: Option<HashMap<String, String>>,
18 environments: HashMap<Arc<Path>, Shared<Task<Option<HashMap<String, String>>>>>,
19 environment_error_messages: HashMap<Arc<Path>, EnvironmentErrorMessage>,
20}
21
22pub enum ProjectEnvironmentEvent {
23 ErrorsUpdated,
24}
25
26impl EventEmitter<ProjectEnvironmentEvent> for ProjectEnvironment {}
27
28impl ProjectEnvironment {
29 pub fn new(cli_environment: Option<HashMap<String, String>>) -> Self {
30 Self {
31 cli_environment,
32 environments: Default::default(),
33 environment_error_messages: Default::default(),
34 }
35 }
36
37 /// Returns the inherited CLI environment, if this project was opened from the Zed CLI.
38 pub(crate) fn get_cli_environment(&self) -> Option<HashMap<String, String>> {
39 if let Some(mut env) = self.cli_environment.clone() {
40 set_origin_marker(&mut env, EnvironmentOrigin::Cli);
41 Some(env)
42 } else {
43 None
44 }
45 }
46
47 /// Returns an iterator over all pairs `(abs_path, error_message)` of
48 /// environment errors associated with this project environment.
49 pub(crate) fn environment_errors(
50 &self,
51 ) -> impl Iterator<Item = (&Arc<Path>, &EnvironmentErrorMessage)> {
52 self.environment_error_messages.iter()
53 }
54
55 pub(crate) fn remove_environment_error(&mut self, abs_path: &Path, cx: &mut Context<Self>) {
56 self.environment_error_messages.remove(abs_path);
57 cx.emit(ProjectEnvironmentEvent::ErrorsUpdated);
58 }
59
60 pub(crate) fn get_buffer_environment(
61 &mut self,
62 buffer: Entity<Buffer>,
63 worktree_store: Entity<WorktreeStore>,
64 cx: &mut Context<Self>,
65 ) -> Shared<Task<Option<HashMap<String, String>>>> {
66 if cfg!(any(test, feature = "test-support")) {
67 return Task::ready(Some(HashMap::default())).shared();
68 }
69
70 if let Some(cli_environment) = self.get_cli_environment() {
71 log::debug!("using project environment variables from CLI");
72 return Task::ready(Some(cli_environment)).shared();
73 }
74
75 let Some(worktree) = buffer
76 .read(cx)
77 .file()
78 .map(|f| f.worktree_id(cx))
79 .and_then(|worktree_id| worktree_store.read(cx).worktree_for_id(worktree_id, cx))
80 else {
81 return Task::ready(None).shared();
82 };
83
84 self.get_worktree_environment(worktree, cx)
85 }
86
87 pub(crate) fn get_worktree_environment(
88 &mut self,
89 worktree: Entity<Worktree>,
90 cx: &mut Context<Self>,
91 ) -> Shared<Task<Option<HashMap<String, String>>>> {
92 if cfg!(any(test, feature = "test-support")) {
93 return Task::ready(Some(HashMap::default())).shared();
94 }
95
96 if let Some(cli_environment) = self.get_cli_environment() {
97 log::debug!("using project environment variables from CLI");
98 return Task::ready(Some(cli_environment)).shared();
99 }
100
101 let mut abs_path = worktree.read(cx).abs_path();
102 if !worktree.read(cx).is_local() {
103 log::error!(
104 "attempted to get project environment for a non-local worktree at {abs_path:?}"
105 );
106 return Task::ready(None).shared();
107 } else if worktree.read(cx).is_single_file() {
108 let Some(parent) = abs_path.parent() else {
109 return Task::ready(None).shared();
110 };
111 abs_path = parent.into();
112 }
113
114 self.get_directory_environment(abs_path, cx)
115 }
116
117 /// Returns the project environment, if possible.
118 /// If the project was opened from the CLI, then the inherited CLI environment is returned.
119 /// If it wasn't opened from the CLI, and an absolute path is given, then a shell is spawned in
120 /// that directory, to get environment variables as if the user has `cd`'d there.
121 pub(crate) fn get_directory_environment(
122 &mut self,
123 abs_path: Arc<Path>,
124 cx: &mut Context<Self>,
125 ) -> Shared<Task<Option<HashMap<String, String>>>> {
126 if cfg!(any(test, feature = "test-support")) {
127 return Task::ready(Some(HashMap::default())).shared();
128 }
129
130 if let Some(cli_environment) = self.get_cli_environment() {
131 log::debug!("using project environment variables from CLI");
132 return Task::ready(Some(cli_environment)).shared();
133 }
134
135 self.environments
136 .entry(abs_path.clone())
137 .or_insert_with(|| get_directory_env_impl(abs_path.clone(), cx).shared())
138 .clone()
139 }
140}
141
142fn set_origin_marker(env: &mut HashMap<String, String>, origin: EnvironmentOrigin) {
143 env.insert(ZED_ENVIRONMENT_ORIGIN_MARKER.to_string(), origin.into());
144}
145
146const ZED_ENVIRONMENT_ORIGIN_MARKER: &str = "ZED_ENVIRONMENT";
147
148enum EnvironmentOrigin {
149 Cli,
150 WorktreeShell,
151}
152
153impl From<EnvironmentOrigin> for String {
154 fn from(val: EnvironmentOrigin) -> Self {
155 match val {
156 EnvironmentOrigin::Cli => "cli".into(),
157 EnvironmentOrigin::WorktreeShell => "worktree-shell".into(),
158 }
159 }
160}
161
162#[derive(Debug)]
163pub struct EnvironmentErrorMessage(pub String);
164
165impl std::fmt::Display for EnvironmentErrorMessage {
166 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
167 write!(f, "{}", self.0)
168 }
169}
170
171impl EnvironmentErrorMessage {
172 #[allow(dead_code)]
173 fn from_str(s: &str) -> Self {
174 Self(String::from(s))
175 }
176}
177
178async fn load_directory_shell_environment(
179 abs_path: &Path,
180 load_direnv: &DirenvSettings,
181) -> (
182 Option<HashMap<String, String>>,
183 Option<EnvironmentErrorMessage>,
184) {
185 match smol::fs::metadata(abs_path).await {
186 Ok(meta) => {
187 let dir = if meta.is_dir() {
188 abs_path
189 } else if let Some(parent) = abs_path.parent() {
190 parent
191 } else {
192 return (
193 None,
194 Some(EnvironmentErrorMessage(format!(
195 "Failed to load shell environment in {}: not a directory",
196 abs_path.display()
197 ))),
198 );
199 };
200
201 load_shell_environment(&dir, load_direnv).await
202 }
203 Err(err) => (
204 None,
205 Some(EnvironmentErrorMessage(format!(
206 "Failed to load shell environment in {}: {}",
207 abs_path.display(),
208 err
209 ))),
210 ),
211 }
212}
213
214#[cfg(any(test, feature = "test-support"))]
215async fn load_shell_environment(
216 _dir: &Path,
217 _load_direnv: &DirenvSettings,
218) -> (
219 Option<HashMap<String, String>>,
220 Option<EnvironmentErrorMessage>,
221) {
222 let fake_env = [("ZED_FAKE_TEST_ENV".into(), "true".into())]
223 .into_iter()
224 .collect();
225 (Some(fake_env), None)
226}
227
228#[cfg(all(target_os = "windows", not(any(test, feature = "test-support"))))]
229async fn load_shell_environment(
230 _dir: &Path,
231 _load_direnv: &DirenvSettings,
232) -> (
233 Option<HashMap<String, String>>,
234 Option<EnvironmentErrorMessage>,
235) {
236 // TODO the current code works with Unix $SHELL only, implement environment loading on windows
237 (None, None)
238}
239
240#[cfg(not(any(target_os = "windows", test, feature = "test-support")))]
241async fn load_shell_environment(
242 dir: &Path,
243 load_direnv: &DirenvSettings,
244) -> (
245 Option<HashMap<String, String>>,
246 Option<EnvironmentErrorMessage>,
247) {
248 use crate::direnv::{DirenvError, load_direnv_environment};
249 use std::path::PathBuf;
250 use util::parse_env_output;
251
252 fn message<T>(with: &str) -> (Option<T>, Option<EnvironmentErrorMessage>) {
253 let message = EnvironmentErrorMessage::from_str(with);
254 (None, Some(message))
255 }
256
257 const MARKER: &str = "ZED_SHELL_START";
258 let Some(shell) = std::env::var("SHELL").log_err() else {
259 return message("Failed to get login environment. SHELL environment variable is not set");
260 };
261 let shell_path = PathBuf::from(&shell);
262 let shell_name = shell_path.file_name().and_then(|f| f.to_str());
263
264 // What we're doing here is to spawn a shell and then `cd` into
265 // the project directory to get the env in there as if the user
266 // `cd`'d into it. We do that because tools like direnv, asdf, ...
267 // hook into `cd` and only set up the env after that.
268 //
269 // If the user selects `Direct` for direnv, it would set an environment
270 // variable that later uses to know that it should not run the hook.
271 // We would include in `.envs` call so it is okay to run the hook
272 // even if direnv direct mode is enabled.
273 //
274 // In certain shells we need to execute additional_command in order to
275 // trigger the behavior of direnv, etc.
276 //
277 //
278 // The `exit 0` is the result of hours of debugging, trying to find out
279 // why running this command here, without `exit 0`, would mess
280 // up signal process for our process so that `ctrl-c` doesn't work
281 // anymore.
282 //
283 // We still don't know why `$SHELL -l -i -c '/usr/bin/env -0'` would
284 // do that, but it does, and `exit 0` helps.
285
286 let command = match shell_name {
287 Some("fish") => format!(
288 "cd '{}'; emit fish_prompt; printf '%s' {MARKER}; /usr/bin/env; exit 0;",
289 dir.display()
290 ),
291 _ => format!(
292 "cd '{}'; printf '%s' {MARKER}; /usr/bin/env; exit 0;",
293 dir.display()
294 ),
295 };
296
297 // csh/tcsh only supports `-l` if it's the only flag. So this won't be a login shell.
298 // Users must rely on vars from `~/.tcshrc` or `~/.cshrc` and not `.login` as a result.
299 let args = match shell_name {
300 Some("tcsh") | Some("csh") => vec!["-i", "-c", &command],
301 _ => vec!["-l", "-i", "-c", &command],
302 };
303
304 let Some(output) = smol::process::Command::new(&shell)
305 .args(&args)
306 .output()
307 .await
308 .log_err()
309 else {
310 return message(
311 "Failed to spawn login shell to source login environment variables. See logs for details",
312 );
313 };
314
315 if !output.status.success() {
316 log::error!("login shell exited with {}", output.status);
317 return message("Login shell exited with nonzero exit code. See logs for details");
318 }
319
320 let stdout = String::from_utf8_lossy(&output.stdout);
321 let Some(env_output_start) = stdout.find(MARKER) else {
322 let stderr = String::from_utf8_lossy(&output.stderr);
323 log::error!(
324 "failed to parse output of `env` command in login shell. stdout: {:?}, stderr: {:?}",
325 stdout,
326 stderr
327 );
328 return message("Failed to parse stdout of env command. See logs for the output");
329 };
330
331 let mut parsed_env = HashMap::default();
332 let env_output = &stdout[env_output_start + MARKER.len()..];
333
334 parse_env_output(env_output, |key, value| {
335 parsed_env.insert(key, value);
336 });
337
338 let (direnv_environment, direnv_error) = match load_direnv {
339 DirenvSettings::ShellHook => (None, None),
340 DirenvSettings::Direct => match load_direnv_environment(&parsed_env, dir).await {
341 Ok(env) => (Some(env), None),
342 Err(err) => (
343 None,
344 <Option<EnvironmentErrorMessage> as From<DirenvError>>::from(err),
345 ),
346 },
347 };
348
349 for (key, value) in direnv_environment.unwrap_or(HashMap::default()) {
350 parsed_env.insert(key, value);
351 }
352
353 (Some(parsed_env), direnv_error)
354}
355
356fn get_directory_env_impl(
357 abs_path: Arc<Path>,
358 cx: &Context<ProjectEnvironment>,
359) -> Task<Option<HashMap<String, String>>> {
360 let load_direnv = ProjectSettings::get_global(cx).load_direnv.clone();
361
362 cx.spawn(async move |this, cx| {
363 let (mut shell_env, error_message) = cx
364 .background_spawn({
365 let abs_path = abs_path.clone();
366 async move { load_directory_shell_environment(&abs_path, &load_direnv).await }
367 })
368 .await;
369
370 if let Some(shell_env) = shell_env.as_mut() {
371 let path = shell_env
372 .get("PATH")
373 .map(|path| path.as_str())
374 .unwrap_or_default();
375 log::info!(
376 "using project environment variables shell launched in {:?}. PATH={:?}",
377 abs_path,
378 path
379 );
380
381 set_origin_marker(shell_env, EnvironmentOrigin::WorktreeShell);
382 }
383
384 if let Some(error) = error_message {
385 this.update(cx, |this, cx| {
386 log::error!("{error}",);
387 this.environment_error_messages.insert(abs_path, error);
388 cx.emit(ProjectEnvironmentEvent::ErrorsUpdated)
389 })
390 .log_err();
391 }
392
393 shell_env
394 })
395}