1// Allow binary to be called Zed for a nice application menu when running executable direcly
2#![allow(non_snake_case)]
3
4use anyhow::{anyhow, Context, Result};
5use assets::Assets;
6use client::{self, http, ChannelList, UserStore};
7use fs::OpenOptions;
8use futures::{channel::oneshot, StreamExt};
9use gpui::{App, AssetSource, Task};
10use log::LevelFilter;
11use parking_lot::Mutex;
12use project::Fs;
13use settings::{self, KeymapFile, Settings, SettingsFileContent};
14use smol::process::Command;
15use std::{env, fs, path::PathBuf, sync::Arc};
16use theme::{ThemeRegistry, DEFAULT_THEME_NAME};
17use util::ResultExt;
18use workspace::{self, AppState, OpenNew, OpenPaths};
19use zed::{
20 self, build_window_options, build_workspace,
21 fs::RealFs,
22 languages, menus,
23 settings_file::{settings_from_files, watch_keymap_file, WatchedJsonFile},
24};
25
26fn main() {
27 init_logger();
28
29 let app = gpui::App::new(Assets).unwrap();
30 load_embedded_fonts(&app);
31
32 let fs = Arc::new(RealFs);
33 let themes = ThemeRegistry::new(Assets, app.font_cache());
34 let theme = themes.get(DEFAULT_THEME_NAME).unwrap();
35 let default_settings = Settings::new("Zed Mono", &app.font_cache(), theme)
36 .unwrap()
37 .with_overrides(
38 languages::PLAIN_TEXT.name(),
39 settings::LanguageOverride {
40 soft_wrap: Some(settings::SoftWrap::PreferredLineLength),
41 ..Default::default()
42 },
43 )
44 .with_overrides(
45 "Markdown",
46 settings::LanguageOverride {
47 soft_wrap: Some(settings::SoftWrap::PreferredLineLength),
48 ..Default::default()
49 },
50 )
51 .with_overrides(
52 "Rust",
53 settings::LanguageOverride {
54 tab_size: Some(4),
55 ..Default::default()
56 },
57 )
58 .with_overrides(
59 "JavaScript",
60 settings::LanguageOverride {
61 tab_size: Some(2),
62 ..Default::default()
63 },
64 )
65 .with_overrides(
66 "TypeScript",
67 settings::LanguageOverride {
68 tab_size: Some(2),
69 ..Default::default()
70 },
71 )
72 .with_overrides(
73 "TSX",
74 settings::LanguageOverride {
75 tab_size: Some(2),
76 ..Default::default()
77 },
78 );
79
80 let config_files = load_config_files(&app, fs.clone());
81
82 let login_shell_env_loaded = if stdout_is_a_pty() {
83 Task::ready(())
84 } else {
85 app.background().spawn(async {
86 load_login_shell_environment().await.log_err();
87 })
88 };
89
90 app.run(move |cx| {
91 let http = http::client();
92 let client = client::Client::new(http.clone());
93 let mut languages = languages::build_language_registry(login_shell_env_loaded);
94 let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http.clone(), cx));
95 let channel_list =
96 cx.add_model(|cx| ChannelList::new(user_store.clone(), client.clone(), cx));
97
98 project::Project::init(&client);
99 client::Channel::init(&client);
100 client::init(client.clone(), cx);
101 command_palette::init(cx);
102 workspace::init(&client, cx);
103 editor::init(cx);
104 go_to_line::init(cx);
105 file_finder::init(cx);
106 chat_panel::init(cx);
107 outline::init(cx);
108 project_symbols::init(cx);
109 project_panel::init(cx);
110 diagnostics::init(cx);
111 search::init(cx);
112 vim::init(cx);
113 cx.spawn({
114 let client = client.clone();
115 |cx| async move {
116 if stdout_is_a_pty() {
117 if client::IMPERSONATE_LOGIN.is_some() {
118 client.authenticate_and_connect(false, &cx).await?;
119 }
120 } else {
121 if client.has_keychain_credentials(&cx) {
122 client.authenticate_and_connect(true, &cx).await?;
123 }
124 }
125 Ok::<_, anyhow::Error>(())
126 }
127 })
128 .detach_and_log_err(cx);
129
130 let (settings_file, keymap_file) = cx.background().block(config_files).unwrap();
131 let mut settings_rx = settings_from_files(
132 default_settings,
133 vec![settings_file],
134 themes.clone(),
135 cx.font_cache().clone(),
136 );
137
138 cx.spawn(|cx| watch_keymap_file(keymap_file, cx)).detach();
139
140 let settings = cx.background().block(settings_rx.next()).unwrap();
141 cx.spawn(|mut cx| async move {
142 while let Some(settings) = settings_rx.next().await {
143 cx.update(|cx| {
144 cx.update_global(|s, _| *s = settings);
145 cx.refresh_windows();
146 });
147 }
148 })
149 .detach();
150
151 languages.set_language_server_download_dir(zed::ROOT_PATH.clone());
152 languages.set_theme(&settings.theme.editor.syntax);
153 cx.set_global(settings);
154
155 let app_state = Arc::new(AppState {
156 languages: Arc::new(languages),
157 themes,
158 channel_list,
159 client,
160 user_store,
161 fs,
162 build_window_options: &build_window_options,
163 build_workspace: &build_workspace,
164 });
165 journal::init(app_state.clone(), cx);
166 theme_selector::init(cx);
167 zed::init(&app_state, cx);
168
169 cx.set_menus(menus::menus(&app_state.clone()));
170
171 if stdout_is_a_pty() {
172 cx.platform().activate(true);
173 }
174
175 let paths = collect_path_args();
176 if paths.is_empty() {
177 cx.dispatch_global_action(OpenNew(app_state.clone()));
178 } else {
179 cx.dispatch_global_action(OpenPaths { paths, app_state });
180 }
181 });
182}
183
184fn init_logger() {
185 if stdout_is_a_pty() {
186 env_logger::init();
187 } else {
188 let level = LevelFilter::Info;
189 let log_dir_path = dirs::home_dir()
190 .expect("could not locate home directory for logging")
191 .join("Library/Logs/");
192 let log_file_path = log_dir_path.join("Zed.log");
193 fs::create_dir_all(&log_dir_path).expect("could not create log directory");
194 let log_file = OpenOptions::new()
195 .create(true)
196 .append(true)
197 .open(log_file_path)
198 .expect("could not open logfile");
199 simplelog::WriteLogger::init(level, simplelog::Config::default(), log_file)
200 .expect("could not initialize logger");
201 log_panics::init();
202 }
203}
204
205async fn load_login_shell_environment() -> Result<()> {
206 let marker = "ZED_LOGIN_SHELL_START";
207 let shell = env::var("SHELL").context(
208 "SHELL environment variable is not assigned so we can't source login environment variables",
209 )?;
210 let output = Command::new(&shell)
211 .args(["-lic", &format!("echo {marker} && /usr/bin/env")])
212 .output()
213 .await
214 .context("failed to spawn login shell to source login environment variables")?;
215 if !output.status.success() {
216 Err(anyhow!("login shell exited with error"))?;
217 }
218
219 let stdout = String::from_utf8_lossy(&output.stdout);
220
221 if let Some(env_output_start) = stdout.find(marker) {
222 let env_output = &stdout[env_output_start + marker.len()..];
223 for line in env_output.lines() {
224 if let Some(separator_index) = line.find('=') {
225 let key = &line[..separator_index];
226 let value = &line[separator_index + 1..];
227 env::set_var(key, value);
228 }
229 }
230 log::info!(
231 "set environment variables from shell:{}, path:{}",
232 shell,
233 env::var("PATH").unwrap_or_default(),
234 );
235 }
236
237 Ok(())
238}
239
240fn stdout_is_a_pty() -> bool {
241 unsafe { libc::isatty(libc::STDOUT_FILENO as i32) != 0 }
242}
243
244fn collect_path_args() -> Vec<PathBuf> {
245 env::args()
246 .skip(1)
247 .filter_map(|arg| match fs::canonicalize(arg) {
248 Ok(path) => Some(path),
249 Err(error) => {
250 log::error!("error parsing path argument: {}", error);
251 None
252 }
253 })
254 .collect::<Vec<_>>()
255}
256
257fn load_embedded_fonts(app: &App) {
258 let font_paths = Assets.list("fonts");
259 let embedded_fonts = Mutex::new(Vec::new());
260 smol::block_on(app.background().scoped(|scope| {
261 for font_path in &font_paths {
262 scope.spawn(async {
263 let font_path = &*font_path;
264 let font_bytes = Assets.load(&font_path).unwrap().to_vec();
265 embedded_fonts.lock().push(Arc::from(font_bytes));
266 });
267 }
268 }));
269 app.platform()
270 .fonts()
271 .add_fonts(&embedded_fonts.into_inner())
272 .unwrap();
273}
274
275fn load_config_files(
276 app: &App,
277 fs: Arc<dyn Fs>,
278) -> oneshot::Receiver<(
279 WatchedJsonFile<SettingsFileContent>,
280 WatchedJsonFile<KeymapFile>,
281)> {
282 let executor = app.background();
283 let (tx, rx) = oneshot::channel();
284 executor
285 .clone()
286 .spawn(async move {
287 let settings_file =
288 WatchedJsonFile::new(fs.clone(), &executor, zed::SETTINGS_PATH.clone()).await;
289 let keymap_file = WatchedJsonFile::new(fs, &executor, zed::KEYMAP_PATH.clone()).await;
290 tx.send((settings_file, keymap_file)).ok()
291 })
292 .detach();
293 rx
294}