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