1mod extension_lsp_adapter;
2mod wasm_host;
3
4#[cfg(test)]
5mod extension_store_test;
6
7use anyhow::{anyhow, bail, Context as _, Result};
8use async_compression::futures::bufread::GzipDecoder;
9use async_tar::Archive;
10use collections::{BTreeMap, HashSet};
11use fs::{Fs, RemoveOptions};
12use futures::{channel::mpsc::unbounded, io::BufReader, AsyncReadExt as _, StreamExt as _};
13use gpui::{actions, AppContext, Context, Global, Model, ModelContext, Task};
14use language::{
15 LanguageConfig, LanguageMatcher, LanguageQueries, LanguageRegistry, LanguageServerName,
16 QUERY_FILENAME_PREFIXES,
17};
18use node_runtime::NodeRuntime;
19use serde::{Deserialize, Serialize};
20use std::{
21 cmp::Ordering,
22 ffi::OsStr,
23 path::{self, Path, PathBuf},
24 sync::Arc,
25 time::Duration,
26};
27use theme::{ThemeRegistry, ThemeSettings};
28use util::{
29 http::{AsyncBody, HttpClient, HttpClientWithUrl},
30 paths::EXTENSIONS_DIR,
31 ResultExt, TryFutureExt,
32};
33use wasm_host::{WasmExtension, WasmHost};
34
35use crate::{extension_lsp_adapter::ExtensionLspAdapter, wasm_host::wit};
36
37#[derive(Deserialize)]
38pub struct ExtensionsApiResponse {
39 pub data: Vec<ExtensionApiResponse>,
40}
41
42#[derive(Clone, Deserialize)]
43pub struct ExtensionApiResponse {
44 pub id: Arc<str>,
45 pub name: String,
46 pub version: Arc<str>,
47 pub description: Option<String>,
48 pub authors: Vec<String>,
49 pub repository: String,
50 pub download_count: usize,
51}
52
53/// This is the old version of the extension manifest, from when it was `extension.json`.
54#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
55pub struct OldExtensionManifest {
56 pub name: String,
57 pub version: Arc<str>,
58
59 #[serde(default)]
60 pub description: Option<String>,
61 #[serde(default)]
62 pub repository: Option<String>,
63 #[serde(default)]
64 pub authors: Vec<String>,
65
66 #[serde(default)]
67 pub themes: BTreeMap<Arc<str>, PathBuf>,
68 #[serde(default)]
69 pub languages: BTreeMap<Arc<str>, PathBuf>,
70 #[serde(default)]
71 pub grammars: BTreeMap<Arc<str>, PathBuf>,
72}
73
74#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
75pub struct ExtensionManifest {
76 pub id: Arc<str>,
77 pub name: String,
78 pub version: Arc<str>,
79
80 #[serde(default)]
81 pub description: Option<String>,
82 #[serde(default)]
83 pub repository: Option<String>,
84 #[serde(default)]
85 pub authors: Vec<String>,
86 #[serde(default)]
87 pub lib: LibManifestEntry,
88
89 #[serde(default)]
90 pub themes: Vec<PathBuf>,
91 #[serde(default)]
92 pub languages: Vec<PathBuf>,
93 #[serde(default)]
94 pub grammars: BTreeMap<Arc<str>, GrammarManifestEntry>,
95 #[serde(default)]
96 pub language_servers: BTreeMap<LanguageServerName, LanguageServerManifestEntry>,
97}
98
99#[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
100pub struct LibManifestEntry {
101 path: Option<PathBuf>,
102}
103
104#[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
105pub struct GrammarManifestEntry {
106 repository: String,
107 #[serde(alias = "commit")]
108 rev: String,
109}
110
111#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
112pub struct LanguageServerManifestEntry {
113 language: Arc<str>,
114}
115
116#[derive(Clone)]
117pub enum ExtensionStatus {
118 NotInstalled,
119 Installing,
120 Upgrading,
121 Installed(Arc<str>),
122 Removing,
123}
124
125impl ExtensionStatus {
126 pub fn is_installing(&self) -> bool {
127 matches!(self, Self::Installing)
128 }
129
130 pub fn is_upgrading(&self) -> bool {
131 matches!(self, Self::Upgrading)
132 }
133
134 pub fn is_removing(&self) -> bool {
135 matches!(self, Self::Removing)
136 }
137}
138
139pub struct ExtensionStore {
140 extension_index: ExtensionIndex,
141 fs: Arc<dyn Fs>,
142 http_client: Arc<HttpClientWithUrl>,
143 extensions_dir: PathBuf,
144 extensions_being_installed: HashSet<Arc<str>>,
145 extensions_being_uninstalled: HashSet<Arc<str>>,
146 manifest_path: PathBuf,
147 language_registry: Arc<LanguageRegistry>,
148 theme_registry: Arc<ThemeRegistry>,
149 modified_extensions: HashSet<Arc<str>>,
150 wasm_host: Arc<WasmHost>,
151 wasm_extensions: Vec<(Arc<ExtensionManifest>, WasmExtension)>,
152 reload_task: Option<Task<Option<()>>>,
153 needs_reload: bool,
154 _watch_extensions_dir: [Task<()>; 2],
155}
156
157struct GlobalExtensionStore(Model<ExtensionStore>);
158
159impl Global for GlobalExtensionStore {}
160
161#[derive(Debug, Deserialize, Serialize, Default, PartialEq, Eq)]
162pub struct ExtensionIndex {
163 pub extensions: BTreeMap<Arc<str>, Arc<ExtensionManifest>>,
164 pub themes: BTreeMap<Arc<str>, ExtensionIndexEntry>,
165 pub languages: BTreeMap<Arc<str>, ExtensionIndexLanguageEntry>,
166}
167
168#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Deserialize, Serialize)]
169pub struct ExtensionIndexEntry {
170 extension: Arc<str>,
171 path: PathBuf,
172}
173
174#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Deserialize, Serialize)]
175pub struct ExtensionIndexLanguageEntry {
176 extension: Arc<str>,
177 path: PathBuf,
178 matcher: LanguageMatcher,
179 grammar: Option<Arc<str>>,
180}
181
182actions!(zed, [ReloadExtensions]);
183
184pub fn init(
185 fs: Arc<fs::RealFs>,
186 http_client: Arc<HttpClientWithUrl>,
187 node_runtime: Arc<dyn NodeRuntime>,
188 language_registry: Arc<LanguageRegistry>,
189 theme_registry: Arc<ThemeRegistry>,
190 cx: &mut AppContext,
191) {
192 let store = cx.new_model(move |cx| {
193 ExtensionStore::new(
194 EXTENSIONS_DIR.clone(),
195 fs,
196 http_client,
197 node_runtime,
198 language_registry,
199 theme_registry,
200 cx,
201 )
202 });
203
204 cx.on_action(|_: &ReloadExtensions, cx| {
205 let store = cx.global::<GlobalExtensionStore>().0.clone();
206 store.update(cx, |store, cx| store.reload(cx))
207 });
208
209 cx.set_global(GlobalExtensionStore(store));
210}
211
212impl ExtensionStore {
213 pub fn global(cx: &AppContext) -> Model<Self> {
214 cx.global::<GlobalExtensionStore>().0.clone()
215 }
216
217 pub fn new(
218 extensions_dir: PathBuf,
219 fs: Arc<dyn Fs>,
220 http_client: Arc<HttpClientWithUrl>,
221 node_runtime: Arc<dyn NodeRuntime>,
222 language_registry: Arc<LanguageRegistry>,
223 theme_registry: Arc<ThemeRegistry>,
224 cx: &mut ModelContext<Self>,
225 ) -> Self {
226 let mut this = Self {
227 extension_index: Default::default(),
228 extensions_dir: extensions_dir.join("installed"),
229 manifest_path: extensions_dir.join("manifest.json"),
230 extensions_being_installed: Default::default(),
231 extensions_being_uninstalled: Default::default(),
232 reload_task: None,
233 wasm_host: WasmHost::new(
234 fs.clone(),
235 http_client.clone(),
236 node_runtime,
237 language_registry.clone(),
238 extensions_dir.join("work"),
239 ),
240 wasm_extensions: Vec::new(),
241 needs_reload: false,
242 modified_extensions: Default::default(),
243 fs,
244 http_client,
245 language_registry,
246 theme_registry,
247 _watch_extensions_dir: [Task::ready(()), Task::ready(())],
248 };
249 this._watch_extensions_dir = this.watch_extensions_dir(cx);
250 this.load(cx);
251 this
252 }
253
254 pub fn load(&mut self, cx: &mut ModelContext<Self>) {
255 let (manifest_content, manifest_metadata, extensions_metadata) =
256 cx.background_executor().block(async {
257 futures::join!(
258 self.fs.load(&self.manifest_path),
259 self.fs.metadata(&self.manifest_path),
260 self.fs.metadata(&self.extensions_dir),
261 )
262 });
263
264 let mut should_reload = true;
265
266 if let Some(manifest_content) = manifest_content.log_err() {
267 if let Some(manifest) = serde_json::from_str(&manifest_content).log_err() {
268 // TODO: don't detach
269 self.extensions_updated(manifest, cx).detach();
270
271 if let (Ok(Some(manifest_metadata)), Ok(Some(extensions_metadata))) =
272 (manifest_metadata, extensions_metadata)
273 {
274 if manifest_metadata.mtime > extensions_metadata.mtime {
275 should_reload = false;
276 }
277 }
278 }
279 }
280
281 if should_reload {
282 self.reload(cx)
283 }
284 }
285
286 pub fn extensions_dir(&self) -> PathBuf {
287 self.extensions_dir.clone()
288 }
289
290 pub fn extension_status(&self, extension_id: &str) -> ExtensionStatus {
291 let is_uninstalling = self.extensions_being_uninstalled.contains(extension_id);
292 if is_uninstalling {
293 return ExtensionStatus::Removing;
294 }
295
296 let installed_version = self
297 .extension_index
298 .extensions
299 .get(extension_id)
300 .map(|manifest| manifest.version.clone());
301 let is_installing = self.extensions_being_installed.contains(extension_id);
302 match (installed_version, is_installing) {
303 (Some(_), true) => ExtensionStatus::Upgrading,
304 (Some(version), false) => ExtensionStatus::Installed(version),
305 (None, true) => ExtensionStatus::Installing,
306 (None, false) => ExtensionStatus::NotInstalled,
307 }
308 }
309
310 pub fn fetch_extensions(
311 &self,
312 search: Option<&str>,
313 cx: &mut ModelContext<Self>,
314 ) -> Task<Result<Vec<ExtensionApiResponse>>> {
315 let url = self.http_client.build_zed_api_url(&format!(
316 "/extensions{query}",
317 query = search
318 .map(|search| format!("?filter={search}"))
319 .unwrap_or_default()
320 ));
321 let http_client = self.http_client.clone();
322 cx.spawn(move |_, _| async move {
323 let mut response = http_client.get(&url, AsyncBody::empty(), true).await?;
324
325 let mut body = Vec::new();
326 response
327 .body_mut()
328 .read_to_end(&mut body)
329 .await
330 .context("error reading extensions")?;
331
332 if response.status().is_client_error() {
333 let text = String::from_utf8_lossy(body.as_slice());
334 bail!(
335 "status error {}, response: {text:?}",
336 response.status().as_u16()
337 );
338 }
339
340 let response: ExtensionsApiResponse = serde_json::from_slice(&body)?;
341
342 Ok(response.data)
343 })
344 }
345
346 pub fn install_extension(
347 &mut self,
348 extension_id: Arc<str>,
349 version: Arc<str>,
350 cx: &mut ModelContext<Self>,
351 ) {
352 log::info!("installing extension {extension_id} {version}");
353 let url = self
354 .http_client
355 .build_zed_api_url(&format!("/extensions/{extension_id}/{version}/download"));
356
357 let extensions_dir = self.extensions_dir();
358 let http_client = self.http_client.clone();
359
360 self.extensions_being_installed.insert(extension_id.clone());
361
362 cx.spawn(move |this, mut cx| async move {
363 let mut response = http_client
364 .get(&url, Default::default(), true)
365 .await
366 .map_err(|err| anyhow!("error downloading extension: {}", err))?;
367 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
368 let archive = Archive::new(decompressed_bytes);
369 archive
370 .unpack(extensions_dir.join(extension_id.as_ref()))
371 .await?;
372
373 this.update(&mut cx, |this, cx| {
374 this.extensions_being_installed
375 .remove(extension_id.as_ref());
376 this.reload(cx)
377 })
378 })
379 .detach_and_log_err(cx);
380 }
381
382 pub fn uninstall_extension(&mut self, extension_id: Arc<str>, cx: &mut ModelContext<Self>) {
383 let extensions_dir = self.extensions_dir();
384 let fs = self.fs.clone();
385
386 self.extensions_being_uninstalled
387 .insert(extension_id.clone());
388
389 cx.spawn(move |this, mut cx| async move {
390 fs.remove_dir(
391 &extensions_dir.join(extension_id.as_ref()),
392 RemoveOptions {
393 recursive: true,
394 ignore_if_not_exists: true,
395 },
396 )
397 .await?;
398
399 this.update(&mut cx, |this, cx| {
400 this.extensions_being_uninstalled
401 .remove(extension_id.as_ref());
402 this.reload(cx)
403 })
404 })
405 .detach_and_log_err(cx)
406 }
407
408 /// Updates the set of installed extensions.
409 ///
410 /// First, this unloads any themes, languages, or grammars that are
411 /// no longer in the manifest, or whose files have changed on disk.
412 /// Then it loads any themes, languages, or grammars that are newly
413 /// added to the manifest, or whose files have changed on disk.
414 fn extensions_updated(
415 &mut self,
416 new_index: ExtensionIndex,
417 cx: &mut ModelContext<Self>,
418 ) -> Task<Result<()>> {
419 fn diff<'a, T, I1, I2>(
420 old_keys: I1,
421 new_keys: I2,
422 modified_keys: &HashSet<Arc<str>>,
423 ) -> (Vec<Arc<str>>, Vec<Arc<str>>)
424 where
425 T: PartialEq,
426 I1: Iterator<Item = (&'a Arc<str>, T)>,
427 I2: Iterator<Item = (&'a Arc<str>, T)>,
428 {
429 let mut removed_keys = Vec::default();
430 let mut added_keys = Vec::default();
431 let mut old_keys = old_keys.peekable();
432 let mut new_keys = new_keys.peekable();
433 loop {
434 match (old_keys.peek(), new_keys.peek()) {
435 (None, None) => return (removed_keys, added_keys),
436 (None, Some(_)) => {
437 added_keys.push(new_keys.next().unwrap().0.clone());
438 }
439 (Some(_), None) => {
440 removed_keys.push(old_keys.next().unwrap().0.clone());
441 }
442 (Some((old_key, _)), Some((new_key, _))) => match old_key.cmp(&new_key) {
443 Ordering::Equal => {
444 let (old_key, old_value) = old_keys.next().unwrap();
445 let (new_key, new_value) = new_keys.next().unwrap();
446 if old_value != new_value || modified_keys.contains(old_key) {
447 removed_keys.push(old_key.clone());
448 added_keys.push(new_key.clone());
449 }
450 }
451 Ordering::Less => {
452 removed_keys.push(old_keys.next().unwrap().0.clone());
453 }
454 Ordering::Greater => {
455 added_keys.push(new_keys.next().unwrap().0.clone());
456 }
457 },
458 }
459 }
460 }
461
462 let old_index = &self.extension_index;
463 let (extensions_to_unload, extensions_to_load) = diff(
464 old_index.extensions.iter(),
465 new_index.extensions.iter(),
466 &self.modified_extensions,
467 );
468 self.modified_extensions.clear();
469
470 let themes_to_remove = old_index
471 .themes
472 .iter()
473 .filter_map(|(name, entry)| {
474 if extensions_to_unload.contains(&entry.extension) {
475 Some(name.clone().into())
476 } else {
477 None
478 }
479 })
480 .collect::<Vec<_>>();
481 let languages_to_remove = old_index
482 .languages
483 .iter()
484 .filter_map(|(name, entry)| {
485 if extensions_to_unload.contains(&entry.extension) {
486 Some(name.clone())
487 } else {
488 None
489 }
490 })
491 .collect::<Vec<_>>();
492 let empty = Default::default();
493 let grammars_to_remove = extensions_to_unload
494 .iter()
495 .flat_map(|extension_id| {
496 old_index
497 .extensions
498 .get(extension_id)
499 .map_or(&empty, |extension| &extension.grammars)
500 .keys()
501 .cloned()
502 })
503 .collect::<Vec<_>>();
504
505 self.wasm_extensions
506 .retain(|(extension, _)| !extensions_to_unload.contains(&extension.id));
507
508 for extension_id in &extensions_to_unload {
509 if let Some(extension) = old_index.extensions.get(extension_id) {
510 for (language_server_name, config) in extension.language_servers.iter() {
511 self.language_registry
512 .remove_lsp_adapter(config.language.as_ref(), language_server_name);
513 }
514 }
515 }
516
517 self.theme_registry.remove_user_themes(&themes_to_remove);
518 self.language_registry
519 .remove_languages(&languages_to_remove, &grammars_to_remove);
520
521 let languages_to_add = new_index
522 .languages
523 .iter()
524 .filter(|(_, entry)| extensions_to_load.contains(&entry.extension))
525 .collect::<Vec<_>>();
526 let mut grammars_to_add = Vec::new();
527 let mut themes_to_add = Vec::new();
528 for extension_id in &extensions_to_load {
529 let Some(extension) = new_index.extensions.get(extension_id) else {
530 continue;
531 };
532
533 grammars_to_add.extend(extension.grammars.keys().map(|grammar_name| {
534 let mut grammar_path = self.extensions_dir.clone();
535 grammar_path.extend([extension_id.as_ref(), "grammars"]);
536 grammar_path.push(grammar_name.as_ref());
537 grammar_path.set_extension("wasm");
538 (grammar_name.clone(), grammar_path)
539 }));
540 themes_to_add.extend(extension.themes.iter().map(|theme_path| {
541 let mut path = self.extensions_dir.clone();
542 path.extend([Path::new(extension_id.as_ref()), theme_path.as_path()]);
543 path
544 }));
545 }
546
547 self.language_registry
548 .register_wasm_grammars(grammars_to_add);
549
550 for (language_name, language) in languages_to_add {
551 let mut language_path = self.extensions_dir.clone();
552 language_path.extend([
553 Path::new(language.extension.as_ref()),
554 language.path.as_path(),
555 ]);
556 self.language_registry.register_language(
557 language_name.clone(),
558 language.grammar.clone(),
559 language.matcher.clone(),
560 None,
561 move || {
562 let config = std::fs::read_to_string(language_path.join("config.toml"))?;
563 let config: LanguageConfig = ::toml::from_str(&config)?;
564 let queries = load_plugin_queries(&language_path);
565 Ok((config, queries))
566 },
567 );
568 }
569
570 let fs = self.fs.clone();
571 let wasm_host = self.wasm_host.clone();
572 let root_dir = self.extensions_dir.clone();
573 let theme_registry = self.theme_registry.clone();
574 let extension_manifests = extensions_to_load
575 .iter()
576 .filter_map(|name| new_index.extensions.get(name).cloned())
577 .collect::<Vec<_>>();
578
579 self.extension_index = new_index;
580 cx.notify();
581
582 cx.spawn(|this, mut cx| async move {
583 cx.background_executor()
584 .spawn({
585 let fs = fs.clone();
586 async move {
587 for theme_path in &themes_to_add {
588 theme_registry
589 .load_user_theme(&theme_path, fs.clone())
590 .await
591 .log_err();
592 }
593 }
594 })
595 .await;
596
597 let mut wasm_extensions = Vec::new();
598 for extension_manifest in extension_manifests {
599 let Some(wasm_path) = &extension_manifest.lib.path else {
600 continue;
601 };
602
603 let mut path = root_dir.clone();
604 path.extend([
605 Path::new(extension_manifest.id.as_ref()),
606 wasm_path.as_path(),
607 ]);
608 let mut wasm_file = fs
609 .open_sync(&path)
610 .await
611 .context("failed to open wasm file")?;
612 let mut wasm_bytes = Vec::new();
613 wasm_file
614 .read_to_end(&mut wasm_bytes)
615 .context("failed to read wasm")?;
616 let wasm_extension = wasm_host
617 .load_extension(
618 wasm_bytes,
619 extension_manifest.clone(),
620 cx.background_executor().clone(),
621 )
622 .await
623 .context("failed to load wasm extension")?;
624 wasm_extensions.push((extension_manifest.clone(), wasm_extension));
625 }
626
627 this.update(&mut cx, |this, cx| {
628 for (manifest, wasm_extension) in &wasm_extensions {
629 for (language_server_name, language_server_config) in &manifest.language_servers
630 {
631 this.language_registry.register_lsp_adapter(
632 language_server_config.language.clone(),
633 Arc::new(ExtensionLspAdapter {
634 extension: wasm_extension.clone(),
635 work_dir: this.wasm_host.work_dir.join(manifest.id.as_ref()),
636 config: wit::LanguageServerConfig {
637 name: language_server_name.0.to_string(),
638 language_name: language_server_config.language.to_string(),
639 },
640 }),
641 );
642 }
643 }
644 this.wasm_extensions.extend(wasm_extensions);
645 ThemeSettings::reload_current_theme(cx)
646 })
647 .ok();
648 Ok(())
649 })
650 }
651
652 fn watch_extensions_dir(&self, cx: &mut ModelContext<Self>) -> [Task<()>; 2] {
653 let fs = self.fs.clone();
654 let extensions_dir = self.extensions_dir.clone();
655 let (changed_extensions_tx, mut changed_extensions_rx) = unbounded();
656
657 let events_task = cx.background_executor().spawn(async move {
658 let mut events = fs.watch(&extensions_dir, Duration::from_millis(250)).await;
659 while let Some(events) = events.next().await {
660 for event in events {
661 let Ok(event_path) = event.path.strip_prefix(&extensions_dir) else {
662 continue;
663 };
664
665 if let Some(path::Component::Normal(extension_dir_name)) =
666 event_path.components().next()
667 {
668 if let Some(extension_id) = extension_dir_name.to_str() {
669 changed_extensions_tx
670 .unbounded_send(Arc::from(extension_id))
671 .ok();
672 }
673 }
674 }
675 }
676 });
677
678 let reload_task = cx.spawn(|this, mut cx| async move {
679 while let Some(changed_extension_id) = changed_extensions_rx.next().await {
680 if this
681 .update(&mut cx, |this, cx| {
682 this.modified_extensions.insert(changed_extension_id);
683 this.reload(cx);
684 })
685 .is_err()
686 {
687 break;
688 }
689 }
690 });
691
692 [events_task, reload_task]
693 }
694
695 fn reload(&mut self, cx: &mut ModelContext<Self>) {
696 if self.reload_task.is_some() {
697 self.needs_reload = true;
698 return;
699 }
700
701 let fs = self.fs.clone();
702 let work_dir = self.wasm_host.work_dir.clone();
703 let extensions_dir = self.extensions_dir.clone();
704 let manifest_path = self.manifest_path.clone();
705 self.needs_reload = false;
706 self.reload_task = Some(cx.spawn(|this, mut cx| {
707 async move {
708 let extension_index = cx
709 .background_executor()
710 .spawn(async move {
711 let mut index = ExtensionIndex::default();
712
713 fs.create_dir(&work_dir).await.log_err();
714 fs.create_dir(&extensions_dir).await.log_err();
715
716 let extension_paths = fs.read_dir(&extensions_dir).await;
717 if let Ok(mut extension_paths) = extension_paths {
718 while let Some(extension_dir) = extension_paths.next().await {
719 let Ok(extension_dir) = extension_dir else {
720 continue;
721 };
722 Self::add_extension_to_index(fs.clone(), extension_dir, &mut index)
723 .await
724 .log_err();
725 }
726 }
727
728 if let Ok(index_json) = serde_json::to_string_pretty(&index) {
729 fs.save(
730 &manifest_path,
731 &index_json.as_str().into(),
732 Default::default(),
733 )
734 .await
735 .context("failed to save extension manifest")
736 .log_err();
737 }
738
739 index
740 })
741 .await;
742
743 if let Ok(task) = this.update(&mut cx, |this, cx| {
744 this.extensions_updated(extension_index, cx)
745 }) {
746 task.await.log_err();
747 }
748
749 this.update(&mut cx, |this, cx| {
750 this.reload_task.take();
751 if this.needs_reload {
752 this.reload(cx);
753 }
754 })
755 }
756 .log_err()
757 }));
758 }
759
760 async fn add_extension_to_index(
761 fs: Arc<dyn Fs>,
762 extension_dir: PathBuf,
763 index: &mut ExtensionIndex,
764 ) -> Result<()> {
765 let extension_name = extension_dir
766 .file_name()
767 .and_then(OsStr::to_str)
768 .ok_or_else(|| anyhow!("invalid extension name"))?;
769
770 let mut extension_manifest_path = extension_dir.join("extension.json");
771 let mut extension_manifest;
772 if fs.is_file(&extension_manifest_path).await {
773 let manifest_content = fs
774 .load(&extension_manifest_path)
775 .await
776 .with_context(|| format!("failed to load {extension_name} extension.json"))?;
777 let manifest_json = serde_json::from_str::<OldExtensionManifest>(&manifest_content)
778 .with_context(|| {
779 format!("invalid extension.json for extension {extension_name}")
780 })?;
781
782 extension_manifest = ExtensionManifest {
783 id: extension_name.into(),
784 name: manifest_json.name,
785 version: manifest_json.version,
786 description: manifest_json.description,
787 repository: manifest_json.repository,
788 authors: manifest_json.authors,
789 lib: Default::default(),
790 themes: {
791 let mut themes = manifest_json.themes.into_values().collect::<Vec<_>>();
792 themes.sort();
793 themes.dedup();
794 themes
795 },
796 languages: {
797 let mut languages = manifest_json.languages.into_values().collect::<Vec<_>>();
798 languages.sort();
799 languages.dedup();
800 languages
801 },
802 grammars: manifest_json
803 .grammars
804 .into_keys()
805 .map(|grammar_name| (grammar_name, Default::default()))
806 .collect(),
807 language_servers: Default::default(),
808 };
809 } else {
810 extension_manifest_path.set_extension("toml");
811 let manifest_content = fs
812 .load(&extension_manifest_path)
813 .await
814 .with_context(|| format!("failed to load {extension_name} extension.toml"))?;
815 extension_manifest = ::toml::from_str(&manifest_content).with_context(|| {
816 format!("invalid extension.json for extension {extension_name}")
817 })?;
818 };
819
820 if let Ok(mut language_paths) = fs.read_dir(&extension_dir.join("languages")).await {
821 while let Some(language_path) = language_paths.next().await {
822 let language_path = language_path?;
823 let Ok(relative_path) = language_path.strip_prefix(&extension_dir) else {
824 continue;
825 };
826 let Ok(Some(fs_metadata)) = fs.metadata(&language_path).await else {
827 continue;
828 };
829 if !fs_metadata.is_dir {
830 continue;
831 }
832 let config = fs.load(&language_path.join("config.toml")).await?;
833 let config = ::toml::from_str::<LanguageConfig>(&config)?;
834
835 let relative_path = relative_path.to_path_buf();
836 if !extension_manifest.languages.contains(&relative_path) {
837 extension_manifest.languages.push(relative_path.clone());
838 }
839
840 index.languages.insert(
841 config.name.clone(),
842 ExtensionIndexLanguageEntry {
843 extension: extension_name.into(),
844 path: relative_path,
845 matcher: config.matcher,
846 grammar: config.grammar,
847 },
848 );
849 }
850 }
851
852 if let Ok(mut theme_paths) = fs.read_dir(&extension_dir.join("themes")).await {
853 while let Some(theme_path) = theme_paths.next().await {
854 let theme_path = theme_path?;
855 let Ok(relative_path) = theme_path.strip_prefix(&extension_dir) else {
856 continue;
857 };
858
859 let Some(theme_family) = ThemeRegistry::read_user_theme(&theme_path, fs.clone())
860 .await
861 .log_err()
862 else {
863 continue;
864 };
865
866 let relative_path = relative_path.to_path_buf();
867 if !extension_manifest.themes.contains(&relative_path) {
868 extension_manifest.themes.push(relative_path.clone());
869 }
870
871 for theme in theme_family.themes {
872 index.themes.insert(
873 theme.name.into(),
874 ExtensionIndexEntry {
875 extension: extension_name.into(),
876 path: relative_path.clone(),
877 },
878 );
879 }
880 }
881 }
882
883 let default_extension_wasm_path = extension_dir.join("extension.wasm");
884 if fs.is_file(&default_extension_wasm_path).await {
885 extension_manifest
886 .lib
887 .path
888 .get_or_insert(default_extension_wasm_path);
889 }
890
891 index
892 .extensions
893 .insert(extension_name.into(), Arc::new(extension_manifest));
894
895 Ok(())
896 }
897}
898
899fn load_plugin_queries(root_path: &Path) -> LanguageQueries {
900 let mut result = LanguageQueries::default();
901 if let Some(entries) = std::fs::read_dir(root_path).log_err() {
902 for entry in entries {
903 let Some(entry) = entry.log_err() else {
904 continue;
905 };
906 let path = entry.path();
907 if let Some(remainder) = path.strip_prefix(root_path).ok().and_then(|p| p.to_str()) {
908 if !remainder.ends_with(".scm") {
909 continue;
910 }
911 for (name, query) in QUERY_FILENAME_PREFIXES {
912 if remainder.starts_with(name) {
913 if let Some(contents) = std::fs::read_to_string(&path).log_err() {
914 match query(&mut result) {
915 None => *query(&mut result) = Some(contents.into()),
916 Some(r) => r.to_mut().push_str(contents.as_ref()),
917 }
918 }
919 break;
920 }
921 }
922 }
923 }
924 }
925 result
926}