1use anyhow::{anyhow, bail, Context as _, Result};
2use async_compression::futures::bufread::GzipDecoder;
3use async_tar::Archive;
4use collections::{BTreeMap, HashSet};
5use fs::{Fs, RemoveOptions};
6use futures::channel::mpsc::unbounded;
7use futures::StreamExt as _;
8use futures::{io::BufReader, AsyncReadExt as _};
9use gpui::{actions, AppContext, Context, Global, Model, ModelContext, Task};
10use language::{
11 LanguageConfig, LanguageMatcher, LanguageQueries, LanguageRegistry, QUERY_FILENAME_PREFIXES,
12};
13use parking_lot::RwLock;
14use serde::{Deserialize, Serialize};
15use std::cmp::Ordering;
16use std::{
17 ffi::OsStr,
18 path::{Path, PathBuf},
19 sync::Arc,
20 time::Duration,
21};
22use theme::{ThemeRegistry, ThemeSettings};
23use util::http::{AsyncBody, HttpClientWithUrl};
24use util::TryFutureExt;
25use util::{http::HttpClient, paths::EXTENSIONS_DIR, ResultExt};
26
27#[cfg(test)]
28mod extension_store_test;
29
30#[derive(Deserialize)]
31pub struct ExtensionsApiResponse {
32 pub data: Vec<Extension>,
33}
34
35#[derive(Clone, Deserialize)]
36pub struct Extension {
37 pub id: Arc<str>,
38 pub version: Arc<str>,
39 pub name: String,
40 pub description: Option<String>,
41 pub authors: Vec<String>,
42 pub repository: String,
43 pub download_count: usize,
44}
45
46#[derive(Clone)]
47pub enum ExtensionStatus {
48 NotInstalled,
49 Installing,
50 Upgrading,
51 Installed(Arc<str>),
52 Removing,
53}
54
55impl ExtensionStatus {
56 pub fn is_installing(&self) -> bool {
57 matches!(self, Self::Installing)
58 }
59
60 pub fn is_upgrading(&self) -> bool {
61 matches!(self, Self::Upgrading)
62 }
63
64 pub fn is_removing(&self) -> bool {
65 matches!(self, Self::Removing)
66 }
67}
68
69pub struct ExtensionStore {
70 manifest: Arc<RwLock<Manifest>>,
71 fs: Arc<dyn Fs>,
72 http_client: Arc<HttpClientWithUrl>,
73 extensions_dir: PathBuf,
74 extensions_being_installed: HashSet<Arc<str>>,
75 extensions_being_uninstalled: HashSet<Arc<str>>,
76 manifest_path: PathBuf,
77 language_registry: Arc<LanguageRegistry>,
78 theme_registry: Arc<ThemeRegistry>,
79 extension_changes: ExtensionChanges,
80 reload_task: Option<Task<Option<()>>>,
81 needs_reload: bool,
82 _watch_extensions_dir: [Task<()>; 2],
83}
84
85struct GlobalExtensionStore(Model<ExtensionStore>);
86
87impl Global for GlobalExtensionStore {}
88
89#[derive(Debug, Deserialize, Serialize, Default)]
90pub struct Manifest {
91 pub extensions: BTreeMap<Arc<str>, Arc<str>>,
92 pub grammars: BTreeMap<Arc<str>, GrammarManifestEntry>,
93 pub languages: BTreeMap<Arc<str>, LanguageManifestEntry>,
94 pub themes: BTreeMap<Arc<str>, ThemeManifestEntry>,
95}
96
97#[derive(PartialEq, Eq, Debug, PartialOrd, Ord, Deserialize, Serialize)]
98pub struct GrammarManifestEntry {
99 extension: String,
100 path: PathBuf,
101}
102
103#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Deserialize, Serialize)]
104pub struct LanguageManifestEntry {
105 extension: String,
106 path: PathBuf,
107 matcher: LanguageMatcher,
108 grammar: Option<Arc<str>>,
109}
110
111#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
112pub struct ThemeManifestEntry {
113 extension: String,
114 path: PathBuf,
115}
116
117#[derive(Default)]
118struct ExtensionChanges {
119 languages: HashSet<Arc<str>>,
120 grammars: HashSet<Arc<str>>,
121 themes: HashSet<Arc<str>>,
122}
123
124actions!(zed, [ReloadExtensions]);
125
126pub fn init(
127 fs: Arc<fs::RealFs>,
128 http_client: Arc<HttpClientWithUrl>,
129 language_registry: Arc<LanguageRegistry>,
130 theme_registry: Arc<ThemeRegistry>,
131 cx: &mut AppContext,
132) {
133 let store = cx.new_model(|cx| {
134 ExtensionStore::new(
135 EXTENSIONS_DIR.clone(),
136 fs.clone(),
137 http_client.clone(),
138 language_registry.clone(),
139 theme_registry,
140 cx,
141 )
142 });
143
144 cx.on_action(|_: &ReloadExtensions, cx| {
145 let store = cx.global::<GlobalExtensionStore>().0.clone();
146 store.update(cx, |store, cx| store.reload(cx))
147 });
148
149 cx.set_global(GlobalExtensionStore(store));
150}
151
152impl ExtensionStore {
153 pub fn global(cx: &AppContext) -> Model<Self> {
154 cx.global::<GlobalExtensionStore>().0.clone()
155 }
156
157 pub fn new(
158 extensions_dir: PathBuf,
159 fs: Arc<dyn Fs>,
160 http_client: Arc<HttpClientWithUrl>,
161 language_registry: Arc<LanguageRegistry>,
162 theme_registry: Arc<ThemeRegistry>,
163 cx: &mut ModelContext<Self>,
164 ) -> Self {
165 let mut this = Self {
166 manifest: Default::default(),
167 extensions_dir: extensions_dir.join("installed"),
168 manifest_path: extensions_dir.join("manifest.json"),
169 extensions_being_installed: Default::default(),
170 extensions_being_uninstalled: Default::default(),
171 reload_task: None,
172 needs_reload: false,
173 extension_changes: ExtensionChanges::default(),
174 fs,
175 http_client,
176 language_registry,
177 theme_registry,
178 _watch_extensions_dir: [Task::ready(()), Task::ready(())],
179 };
180 this._watch_extensions_dir = this.watch_extensions_dir(cx);
181 this.load(cx);
182 this
183 }
184
185 pub fn load(&mut self, cx: &mut ModelContext<Self>) {
186 let (manifest_content, manifest_metadata, extensions_metadata) =
187 cx.background_executor().block(async {
188 futures::join!(
189 self.fs.load(&self.manifest_path),
190 self.fs.metadata(&self.manifest_path),
191 self.fs.metadata(&self.extensions_dir),
192 )
193 });
194
195 if let Some(manifest_content) = manifest_content.log_err() {
196 if let Some(manifest) = serde_json::from_str(&manifest_content).log_err() {
197 self.manifest_updated(manifest, cx);
198 }
199 }
200
201 let should_reload = if let (Ok(Some(manifest_metadata)), Ok(Some(extensions_metadata))) =
202 (manifest_metadata, extensions_metadata)
203 {
204 extensions_metadata.mtime > manifest_metadata.mtime
205 } else {
206 true
207 };
208
209 if should_reload {
210 self.reload(cx)
211 }
212 }
213
214 pub fn extensions_dir(&self) -> PathBuf {
215 self.extensions_dir.clone()
216 }
217
218 pub fn extension_status(&self, extension_id: &str) -> ExtensionStatus {
219 let is_uninstalling = self.extensions_being_uninstalled.contains(extension_id);
220 if is_uninstalling {
221 return ExtensionStatus::Removing;
222 }
223
224 let installed_version = self.manifest.read().extensions.get(extension_id).cloned();
225 let is_installing = self.extensions_being_installed.contains(extension_id);
226 match (installed_version, is_installing) {
227 (Some(_), true) => ExtensionStatus::Upgrading,
228 (Some(version), false) => ExtensionStatus::Installed(version.clone()),
229 (None, true) => ExtensionStatus::Installing,
230 (None, false) => ExtensionStatus::NotInstalled,
231 }
232 }
233
234 pub fn fetch_extensions(
235 &self,
236 search: Option<&str>,
237 cx: &mut ModelContext<Self>,
238 ) -> Task<Result<Vec<Extension>>> {
239 let url = self.http_client.build_zed_api_url(&format!(
240 "/extensions{query}",
241 query = search
242 .map(|search| format!("?filter={search}"))
243 .unwrap_or_default()
244 ));
245 let http_client = self.http_client.clone();
246 cx.spawn(move |_, _| async move {
247 let mut response = http_client.get(&url, AsyncBody::empty(), true).await?;
248
249 let mut body = Vec::new();
250 response
251 .body_mut()
252 .read_to_end(&mut body)
253 .await
254 .context("error reading extensions")?;
255
256 if response.status().is_client_error() {
257 let text = String::from_utf8_lossy(body.as_slice());
258 bail!(
259 "status error {}, response: {text:?}",
260 response.status().as_u16()
261 );
262 }
263
264 let response: ExtensionsApiResponse = serde_json::from_slice(&body)?;
265
266 Ok(response.data)
267 })
268 }
269
270 pub fn install_extension(
271 &mut self,
272 extension_id: Arc<str>,
273 version: Arc<str>,
274 cx: &mut ModelContext<Self>,
275 ) {
276 log::info!("installing extension {extension_id} {version}");
277 let url = self
278 .http_client
279 .build_zed_api_url(&format!("/extensions/{extension_id}/{version}/download"));
280
281 let extensions_dir = self.extensions_dir();
282 let http_client = self.http_client.clone();
283
284 self.extensions_being_installed.insert(extension_id.clone());
285
286 cx.spawn(move |this, mut cx| async move {
287 let mut response = http_client
288 .get(&url, Default::default(), true)
289 .await
290 .map_err(|err| anyhow!("error downloading extension: {}", err))?;
291 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
292 let archive = Archive::new(decompressed_bytes);
293 archive
294 .unpack(extensions_dir.join(extension_id.as_ref()))
295 .await?;
296
297 this.update(&mut cx, |this, cx| {
298 this.extensions_being_installed
299 .remove(extension_id.as_ref());
300 this.reload(cx)
301 })
302 })
303 .detach_and_log_err(cx);
304 }
305
306 pub fn uninstall_extension(&mut self, extension_id: Arc<str>, cx: &mut ModelContext<Self>) {
307 let extensions_dir = self.extensions_dir();
308 let fs = self.fs.clone();
309
310 self.extensions_being_uninstalled
311 .insert(extension_id.clone());
312
313 cx.spawn(move |this, mut cx| async move {
314 fs.remove_dir(
315 &extensions_dir.join(extension_id.as_ref()),
316 RemoveOptions {
317 recursive: true,
318 ignore_if_not_exists: true,
319 },
320 )
321 .await?;
322
323 this.update(&mut cx, |this, cx| {
324 this.extensions_being_uninstalled
325 .remove(extension_id.as_ref());
326 this.reload(cx)
327 })
328 })
329 .detach_and_log_err(cx)
330 }
331
332 /// Updates the set of installed extensions.
333 ///
334 /// First, this unloads any themes, languages, or grammars that are
335 /// no longer in the manifest, or whose files have changed on disk.
336 /// Then it loads any themes, languages, or grammars that are newly
337 /// added to the manifest, or whose files have changed on disk.
338 fn manifest_updated(&mut self, manifest: Manifest, cx: &mut ModelContext<Self>) {
339 fn diff<'a, T, I1, I2>(
340 old_keys: I1,
341 new_keys: I2,
342 modified_keys: &HashSet<Arc<str>>,
343 ) -> (Vec<Arc<str>>, Vec<Arc<str>>)
344 where
345 T: PartialEq,
346 I1: Iterator<Item = (&'a Arc<str>, T)>,
347 I2: Iterator<Item = (&'a Arc<str>, T)>,
348 {
349 let mut removed_keys = Vec::default();
350 let mut added_keys = Vec::default();
351 let mut old_keys = old_keys.peekable();
352 let mut new_keys = new_keys.peekable();
353 loop {
354 match (old_keys.peek(), new_keys.peek()) {
355 (None, None) => return (removed_keys, added_keys),
356 (None, Some(_)) => {
357 added_keys.push(new_keys.next().unwrap().0.clone());
358 }
359 (Some(_), None) => {
360 removed_keys.push(old_keys.next().unwrap().0.clone());
361 }
362 (Some((old_key, _)), Some((new_key, _))) => match old_key.cmp(&new_key) {
363 Ordering::Equal => {
364 let (old_key, old_value) = old_keys.next().unwrap();
365 let (new_key, new_value) = new_keys.next().unwrap();
366 if old_value != new_value || modified_keys.contains(old_key) {
367 removed_keys.push(old_key.clone());
368 added_keys.push(new_key.clone());
369 }
370 }
371 Ordering::Less => {
372 removed_keys.push(old_keys.next().unwrap().0.clone());
373 }
374 Ordering::Greater => {
375 added_keys.push(new_keys.next().unwrap().0.clone());
376 }
377 },
378 }
379 }
380 }
381
382 let old_manifest = self.manifest.read();
383 let (languages_to_remove, languages_to_add) = diff(
384 old_manifest.languages.iter(),
385 manifest.languages.iter(),
386 &self.extension_changes.languages,
387 );
388 let (grammars_to_remove, grammars_to_add) = diff(
389 old_manifest.grammars.iter(),
390 manifest.grammars.iter(),
391 &self.extension_changes.grammars,
392 );
393 let (themes_to_remove, themes_to_add) = diff(
394 old_manifest.themes.iter(),
395 manifest.themes.iter(),
396 &self.extension_changes.themes,
397 );
398 self.extension_changes.clear();
399 drop(old_manifest);
400
401 let themes_to_remove = &themes_to_remove
402 .into_iter()
403 .map(|theme| theme.into())
404 .collect::<Vec<_>>();
405 self.theme_registry.remove_user_themes(&themes_to_remove);
406 self.language_registry
407 .remove_languages(&languages_to_remove, &grammars_to_remove);
408
409 self.language_registry
410 .register_wasm_grammars(grammars_to_add.iter().map(|grammar_name| {
411 let grammar = manifest.grammars.get(grammar_name).unwrap();
412 let mut grammar_path = self.extensions_dir.clone();
413 grammar_path.extend([grammar.extension.as_ref(), grammar.path.as_path()]);
414 (grammar_name.clone(), grammar_path)
415 }));
416
417 for language_name in &languages_to_add {
418 if language_name.as_ref() == "Swift" {
419 continue;
420 }
421
422 let language = manifest.languages.get(language_name.as_ref()).unwrap();
423 let mut language_path = self.extensions_dir.clone();
424 language_path.extend([language.extension.as_ref(), language.path.as_path()]);
425 self.language_registry.register_language(
426 language_name.clone(),
427 language.grammar.clone(),
428 language.matcher.clone(),
429 vec![],
430 move || {
431 let config = std::fs::read_to_string(language_path.join("config.toml"))?;
432 let config: LanguageConfig = ::toml::from_str(&config)?;
433 let queries = load_plugin_queries(&language_path);
434 Ok((config, queries))
435 },
436 );
437 }
438
439 let (reload_theme_tx, mut reload_theme_rx) = unbounded();
440 let fs = self.fs.clone();
441 let root_dir = self.extensions_dir.clone();
442 let theme_registry = self.theme_registry.clone();
443 let themes = themes_to_add
444 .iter()
445 .filter_map(|name| manifest.themes.get(name).cloned())
446 .collect::<Vec<_>>();
447 cx.background_executor()
448 .spawn(async move {
449 for theme in &themes {
450 let mut theme_path = root_dir.clone();
451 theme_path.extend([theme.extension.as_ref(), theme.path.as_path()]);
452
453 theme_registry
454 .load_user_theme(&theme_path, fs.clone())
455 .await
456 .log_err();
457 }
458
459 reload_theme_tx.unbounded_send(()).ok();
460 })
461 .detach();
462
463 cx.spawn(|_, cx| async move {
464 while let Some(_) = reload_theme_rx.next().await {
465 if cx
466 .update(|cx| ThemeSettings::reload_current_theme(cx))
467 .is_err()
468 {
469 break;
470 }
471 }
472 })
473 .detach();
474
475 *self.manifest.write() = manifest;
476 cx.notify();
477 }
478
479 fn watch_extensions_dir(&self, cx: &mut ModelContext<Self>) -> [Task<()>; 2] {
480 let manifest = self.manifest.clone();
481 let fs = self.fs.clone();
482 let extensions_dir = self.extensions_dir.clone();
483
484 let (changes_tx, mut changes_rx) = unbounded();
485
486 let events_task = cx.background_executor().spawn(async move {
487 let mut events = fs.watch(&extensions_dir, Duration::from_millis(250)).await;
488 while let Some(events) = events.next().await {
489 let mut changed_grammars = HashSet::default();
490 let mut changed_languages = HashSet::default();
491 let mut changed_themes = HashSet::default();
492
493 {
494 let manifest = manifest.read();
495 for event in events {
496 for (grammar_name, grammar) in &manifest.grammars {
497 let mut grammar_path = extensions_dir.clone();
498 grammar_path
499 .extend([grammar.extension.as_ref(), grammar.path.as_path()]);
500 if event.path.starts_with(&grammar_path) || event.path == grammar_path {
501 changed_grammars.insert(grammar_name.clone());
502 }
503 }
504
505 for (language_name, language) in &manifest.languages {
506 let mut language_path = extensions_dir.clone();
507 language_path
508 .extend([language.extension.as_ref(), language.path.as_path()]);
509 if event.path.starts_with(&language_path) || event.path == language_path
510 {
511 changed_languages.insert(language_name.clone());
512 }
513 }
514
515 for (theme_name, theme) in &manifest.themes {
516 let mut theme_path = extensions_dir.clone();
517 theme_path.extend([theme.extension.as_ref(), theme.path.as_path()]);
518 if event.path.starts_with(&theme_path) || event.path == theme_path {
519 changed_themes.insert(theme_name.clone());
520 }
521 }
522 }
523 }
524
525 changes_tx
526 .unbounded_send(ExtensionChanges {
527 languages: changed_languages,
528 grammars: changed_grammars,
529 themes: changed_themes,
530 })
531 .ok();
532 }
533 });
534
535 let reload_task = cx.spawn(|this, mut cx| async move {
536 while let Some(changes) = changes_rx.next().await {
537 if this
538 .update(&mut cx, |this, cx| {
539 this.extension_changes.merge(changes);
540 this.reload(cx);
541 })
542 .is_err()
543 {
544 break;
545 }
546 }
547 });
548
549 [events_task, reload_task]
550 }
551
552 fn reload(&mut self, cx: &mut ModelContext<Self>) {
553 if self.reload_task.is_some() {
554 self.needs_reload = true;
555 return;
556 }
557
558 let fs = self.fs.clone();
559 let extensions_dir = self.extensions_dir.clone();
560 let manifest_path = self.manifest_path.clone();
561 self.needs_reload = false;
562 self.reload_task = Some(cx.spawn(|this, mut cx| {
563 async move {
564 let manifest = cx
565 .background_executor()
566 .spawn(async move {
567 let mut manifest = Manifest::default();
568
569 fs.create_dir(&extensions_dir).await.log_err();
570
571 let extension_paths = fs.read_dir(&extensions_dir).await;
572 if let Ok(mut extension_paths) = extension_paths {
573 while let Some(extension_dir) = extension_paths.next().await {
574 let Ok(extension_dir) = extension_dir else {
575 continue;
576 };
577 Self::add_extension_to_manifest(
578 fs.clone(),
579 extension_dir,
580 &mut manifest,
581 )
582 .await
583 .log_err();
584 }
585 }
586
587 if let Ok(manifest_json) = serde_json::to_string_pretty(&manifest) {
588 fs.save(
589 &manifest_path,
590 &manifest_json.as_str().into(),
591 Default::default(),
592 )
593 .await
594 .context("failed to save extension manifest")
595 .log_err();
596 }
597
598 manifest
599 })
600 .await;
601
602 this.update(&mut cx, |this, cx| {
603 this.manifest_updated(manifest, cx);
604 this.reload_task.take();
605 if this.needs_reload {
606 this.reload(cx);
607 }
608 })
609 }
610 .log_err()
611 }));
612 }
613
614 async fn add_extension_to_manifest(
615 fs: Arc<dyn Fs>,
616 extension_dir: PathBuf,
617 manifest: &mut Manifest,
618 ) -> Result<()> {
619 let extension_name = extension_dir
620 .file_name()
621 .and_then(OsStr::to_str)
622 .ok_or_else(|| anyhow!("invalid extension name"))?;
623
624 #[derive(Deserialize)]
625 struct ExtensionJson {
626 pub version: String,
627 }
628
629 let extension_json_path = extension_dir.join("extension.json");
630 let extension_json = fs
631 .load(&extension_json_path)
632 .await
633 .context("failed to load extension.json")?;
634 let extension_json: ExtensionJson =
635 serde_json::from_str(&extension_json).context("invalid extension.json")?;
636
637 manifest
638 .extensions
639 .insert(extension_name.into(), extension_json.version.into());
640
641 if let Ok(mut grammar_paths) = fs.read_dir(&extension_dir.join("grammars")).await {
642 while let Some(grammar_path) = grammar_paths.next().await {
643 let grammar_path = grammar_path?;
644 let Ok(relative_path) = grammar_path.strip_prefix(&extension_dir) else {
645 continue;
646 };
647 let Some(grammar_name) = grammar_path.file_stem().and_then(OsStr::to_str) else {
648 continue;
649 };
650
651 manifest.grammars.insert(
652 grammar_name.into(),
653 GrammarManifestEntry {
654 extension: extension_name.into(),
655 path: relative_path.into(),
656 },
657 );
658 }
659 }
660
661 if let Ok(mut language_paths) = fs.read_dir(&extension_dir.join("languages")).await {
662 while let Some(language_path) = language_paths.next().await {
663 let language_path = language_path?;
664 let Ok(relative_path) = language_path.strip_prefix(&extension_dir) else {
665 continue;
666 };
667 let Ok(Some(fs_metadata)) = fs.metadata(&language_path).await else {
668 continue;
669 };
670 if !fs_metadata.is_dir {
671 continue;
672 }
673 let config = fs.load(&language_path.join("config.toml")).await?;
674 let config = ::toml::from_str::<LanguageConfig>(&config)?;
675
676 manifest.languages.insert(
677 config.name.clone(),
678 LanguageManifestEntry {
679 extension: extension_name.into(),
680 path: relative_path.into(),
681 matcher: config.matcher,
682 grammar: config.grammar,
683 },
684 );
685 }
686 }
687
688 if let Ok(mut theme_paths) = fs.read_dir(&extension_dir.join("themes")).await {
689 while let Some(theme_path) = theme_paths.next().await {
690 let theme_path = theme_path?;
691 let Ok(relative_path) = theme_path.strip_prefix(&extension_dir) else {
692 continue;
693 };
694
695 let Some(theme_family) = ThemeRegistry::read_user_theme(&theme_path, fs.clone())
696 .await
697 .log_err()
698 else {
699 continue;
700 };
701
702 for theme in theme_family.themes {
703 let location = ThemeManifestEntry {
704 extension: extension_name.into(),
705 path: relative_path.into(),
706 };
707
708 manifest.themes.insert(theme.name.into(), location);
709 }
710 }
711 }
712
713 Ok(())
714 }
715}
716
717impl ExtensionChanges {
718 fn clear(&mut self) {
719 self.grammars.clear();
720 self.languages.clear();
721 self.themes.clear();
722 }
723
724 fn merge(&mut self, other: Self) {
725 self.grammars.extend(other.grammars);
726 self.languages.extend(other.languages);
727 self.themes.extend(other.themes);
728 }
729}
730
731fn load_plugin_queries(root_path: &Path) -> LanguageQueries {
732 let mut result = LanguageQueries::default();
733 if let Some(entries) = std::fs::read_dir(root_path).log_err() {
734 for entry in entries {
735 let Some(entry) = entry.log_err() else {
736 continue;
737 };
738 let path = entry.path();
739 if let Some(remainder) = path.strip_prefix(root_path).ok().and_then(|p| p.to_str()) {
740 if !remainder.ends_with(".scm") {
741 continue;
742 }
743 for (name, query) in QUERY_FILENAME_PREFIXES {
744 if remainder.starts_with(name) {
745 if let Some(contents) = std::fs::read_to_string(&path).log_err() {
746 match query(&mut result) {
747 None => *query(&mut result) = Some(contents.into()),
748 Some(r) => r.to_mut().push_str(contents.as_ref()),
749 }
750 }
751 break;
752 }
753 }
754 }
755 }
756 }
757 result
758}