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