1mod build_extension;
2mod extension_lsp_adapter;
3mod extension_manifest;
4mod wasm_host;
5
6#[cfg(test)]
7mod extension_store_test;
8
9use crate::{extension_lsp_adapter::ExtensionLspAdapter, wasm_host::wit};
10use anyhow::{anyhow, bail, Context as _, Result};
11use async_compression::futures::bufread::GzipDecoder;
12use async_tar::Archive;
13use build_extension::{CompileExtensionOptions, ExtensionBuilder};
14use collections::{hash_map, BTreeMap, HashMap, HashSet};
15use extension_manifest::ExtensionLibraryKind;
16use fs::{Fs, RemoveOptions};
17use futures::{
18 channel::{
19 mpsc::{unbounded, UnboundedSender},
20 oneshot,
21 },
22 io::BufReader,
23 select_biased, AsyncReadExt as _, Future, FutureExt as _, StreamExt as _,
24};
25use gpui::{actions, AppContext, Context, EventEmitter, Global, Model, ModelContext, Task};
26use language::{
27 LanguageConfig, LanguageMatcher, LanguageQueries, LanguageRegistry, QUERY_FILENAME_PREFIXES,
28};
29use node_runtime::NodeRuntime;
30use serde::{Deserialize, Serialize};
31use std::{
32 cmp::Ordering,
33 ffi::OsStr,
34 path::{self, Path, PathBuf},
35 sync::Arc,
36 time::{Duration, Instant},
37};
38use theme::{ThemeRegistry, ThemeSettings};
39use util::{
40 http::{AsyncBody, HttpClient, HttpClientWithUrl},
41 paths::EXTENSIONS_DIR,
42 ResultExt,
43};
44use wasm_host::{WasmExtension, WasmHost};
45
46pub use extension_manifest::{ExtensionManifest, GrammarManifestEntry, OldExtensionManifest};
47
48const RELOAD_DEBOUNCE_DURATION: Duration = Duration::from_millis(200);
49const FS_WATCH_LATENCY: Duration = Duration::from_millis(100);
50
51#[derive(Deserialize)]
52pub struct ExtensionsApiResponse {
53 pub data: Vec<ExtensionApiResponse>,
54}
55
56#[derive(Clone, Deserialize)]
57pub struct ExtensionApiResponse {
58 pub id: Arc<str>,
59 pub name: String,
60 pub version: Arc<str>,
61 pub description: Option<String>,
62 pub authors: Vec<String>,
63 pub repository: String,
64 pub download_count: usize,
65}
66
67pub struct ExtensionStore {
68 builder: Arc<ExtensionBuilder>,
69 extension_index: ExtensionIndex,
70 fs: Arc<dyn Fs>,
71 http_client: Arc<HttpClientWithUrl>,
72 reload_tx: UnboundedSender<Option<Arc<str>>>,
73 reload_complete_senders: Vec<oneshot::Sender<()>>,
74 installed_dir: PathBuf,
75 outstanding_operations: HashMap<Arc<str>, ExtensionOperation>,
76 index_path: PathBuf,
77 language_registry: Arc<LanguageRegistry>,
78 theme_registry: Arc<ThemeRegistry>,
79 modified_extensions: HashSet<Arc<str>>,
80 wasm_host: Arc<WasmHost>,
81 wasm_extensions: Vec<(Arc<ExtensionManifest>, WasmExtension)>,
82 tasks: Vec<Task<()>>,
83}
84
85#[derive(Clone)]
86pub enum ExtensionStatus {
87 NotInstalled,
88 Installing,
89 Upgrading,
90 Installed(Arc<str>),
91 Removing,
92}
93
94enum ExtensionOperation {
95 Upgrade,
96 Install,
97 Remove,
98}
99
100#[derive(Copy, Clone)]
101pub enum Event {
102 ExtensionsUpdated,
103}
104
105impl EventEmitter<Event> for ExtensionStore {}
106
107struct GlobalExtensionStore(Model<ExtensionStore>);
108
109impl Global for GlobalExtensionStore {}
110
111#[derive(Debug, Deserialize, Serialize, Default, PartialEq, Eq)]
112pub struct ExtensionIndex {
113 pub extensions: BTreeMap<Arc<str>, ExtensionIndexEntry>,
114 pub themes: BTreeMap<Arc<str>, ExtensionIndexThemeEntry>,
115 pub languages: BTreeMap<Arc<str>, ExtensionIndexLanguageEntry>,
116}
117
118#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
119pub struct ExtensionIndexEntry {
120 manifest: Arc<ExtensionManifest>,
121 dev: bool,
122}
123
124#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Deserialize, Serialize)]
125pub struct ExtensionIndexThemeEntry {
126 extension: Arc<str>,
127 path: PathBuf,
128}
129
130#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Deserialize, Serialize)]
131pub struct ExtensionIndexLanguageEntry {
132 extension: Arc<str>,
133 path: PathBuf,
134 matcher: LanguageMatcher,
135 grammar: Option<Arc<str>>,
136}
137
138actions!(zed, [ReloadExtensions]);
139
140pub fn init(
141 fs: Arc<fs::RealFs>,
142 http_client: Arc<HttpClientWithUrl>,
143 node_runtime: Arc<dyn NodeRuntime>,
144 language_registry: Arc<LanguageRegistry>,
145 theme_registry: Arc<ThemeRegistry>,
146 cx: &mut AppContext,
147) {
148 let store = cx.new_model(move |cx| {
149 ExtensionStore::new(
150 EXTENSIONS_DIR.clone(),
151 fs,
152 http_client,
153 node_runtime,
154 language_registry,
155 theme_registry,
156 cx,
157 )
158 });
159
160 cx.on_action(|_: &ReloadExtensions, cx| {
161 let store = cx.global::<GlobalExtensionStore>().0.clone();
162 store.update(cx, |store, _| drop(store.reload(None)));
163 });
164
165 cx.set_global(GlobalExtensionStore(store));
166}
167
168impl ExtensionStore {
169 pub fn global(cx: &AppContext) -> Model<Self> {
170 cx.global::<GlobalExtensionStore>().0.clone()
171 }
172
173 pub fn new(
174 extensions_dir: PathBuf,
175 fs: Arc<dyn Fs>,
176 http_client: Arc<HttpClientWithUrl>,
177 node_runtime: Arc<dyn NodeRuntime>,
178 language_registry: Arc<LanguageRegistry>,
179 theme_registry: Arc<ThemeRegistry>,
180 cx: &mut ModelContext<Self>,
181 ) -> Self {
182 let work_dir = extensions_dir.join("work");
183 let build_dir = extensions_dir.join("build");
184 let installed_dir = extensions_dir.join("installed");
185 let index_path = extensions_dir.join("index.json");
186
187 let (reload_tx, mut reload_rx) = unbounded();
188 let mut this = Self {
189 extension_index: Default::default(),
190 installed_dir,
191 index_path,
192 builder: Arc::new(ExtensionBuilder::new(build_dir, http_client.clone())),
193 outstanding_operations: Default::default(),
194 modified_extensions: Default::default(),
195 reload_complete_senders: Vec::new(),
196 wasm_host: WasmHost::new(
197 fs.clone(),
198 http_client.clone(),
199 node_runtime,
200 language_registry.clone(),
201 work_dir,
202 ),
203 wasm_extensions: Vec::new(),
204 fs,
205 http_client,
206 language_registry,
207 theme_registry,
208 reload_tx,
209 tasks: Vec::new(),
210 };
211
212 // The extensions store maintains an index file, which contains a complete
213 // list of the installed extensions and the resources that they provide.
214 // This index is loaded synchronously on startup.
215 let (index_content, index_metadata, extensions_metadata) =
216 cx.background_executor().block(async {
217 futures::join!(
218 this.fs.load(&this.index_path),
219 this.fs.metadata(&this.index_path),
220 this.fs.metadata(&this.installed_dir),
221 )
222 });
223
224 // Normally, there is no need to rebuild the index. But if the index file
225 // is invalid or is out-of-date according to the filesystem mtimes, then
226 // it must be asynchronously rebuilt.
227 let mut extension_index = ExtensionIndex::default();
228 let mut extension_index_needs_rebuild = true;
229 if let Some(index_content) = index_content.log_err() {
230 if let Some(index) = serde_json::from_str(&index_content).log_err() {
231 extension_index = index;
232 if let (Ok(Some(index_metadata)), Ok(Some(extensions_metadata))) =
233 (index_metadata, extensions_metadata)
234 {
235 if index_metadata.mtime > extensions_metadata.mtime {
236 extension_index_needs_rebuild = false;
237 }
238 }
239 }
240 }
241
242 // Immediately load all of the extensions in the initial manifest. If the
243 // index needs to be rebuild, then enqueue
244 let load_initial_extensions = this.extensions_updated(extension_index, cx);
245 if extension_index_needs_rebuild {
246 let _ = this.reload(None);
247 }
248
249 // Perform all extension loading in a single task to ensure that we
250 // never attempt to simultaneously load/unload extensions from multiple
251 // parallel tasks.
252 this.tasks.push(cx.spawn(|this, mut cx| {
253 async move {
254 load_initial_extensions.await;
255
256 let mut debounce_timer = cx
257 .background_executor()
258 .timer(RELOAD_DEBOUNCE_DURATION)
259 .fuse();
260 loop {
261 select_biased! {
262 _ = debounce_timer => {
263 let index = this
264 .update(&mut cx, |this, cx| this.rebuild_extension_index(cx))?
265 .await;
266 this.update(&mut cx, |this, cx| this.extensions_updated(index, cx))?
267 .await;
268 }
269 extension_id = reload_rx.next() => {
270 let Some(extension_id) = extension_id else { break; };
271 this.update(&mut cx, |this, _| {
272 this.modified_extensions.extend(extension_id);
273 })?;
274 debounce_timer = cx.background_executor()
275 .timer(RELOAD_DEBOUNCE_DURATION)
276 .fuse();
277 }
278 }
279 }
280
281 anyhow::Ok(())
282 }
283 .map(drop)
284 }));
285
286 // Watch the installed extensions directory for changes. Whenever changes are
287 // detected, rebuild the extension index, and load/unload any extensions that
288 // have been added, removed, or modified.
289 this.tasks.push(cx.background_executor().spawn({
290 let fs = this.fs.clone();
291 let reload_tx = this.reload_tx.clone();
292 let installed_dir = this.installed_dir.clone();
293 async move {
294 let mut events = fs.watch(&installed_dir, FS_WATCH_LATENCY).await;
295 while let Some(events) = events.next().await {
296 for event in events {
297 let Ok(event_path) = event.path.strip_prefix(&installed_dir) else {
298 continue;
299 };
300
301 if let Some(path::Component::Normal(extension_dir_name)) =
302 event_path.components().next()
303 {
304 if let Some(extension_id) = extension_dir_name.to_str() {
305 reload_tx.unbounded_send(Some(extension_id.into())).ok();
306 }
307 }
308 }
309 }
310 }
311 }));
312
313 this
314 }
315
316 fn reload(&mut self, modified_extension: Option<Arc<str>>) -> impl Future<Output = ()> {
317 let (tx, rx) = oneshot::channel();
318 self.reload_complete_senders.push(tx);
319 self.reload_tx
320 .unbounded_send(modified_extension)
321 .expect("reload task exited");
322 async move {
323 rx.await.ok();
324 }
325 }
326
327 fn extensions_dir(&self) -> PathBuf {
328 self.installed_dir.clone()
329 }
330
331 pub fn extension_status(&self, extension_id: &str) -> ExtensionStatus {
332 match self.outstanding_operations.get(extension_id) {
333 Some(ExtensionOperation::Install) => ExtensionStatus::Installing,
334 Some(ExtensionOperation::Remove) => ExtensionStatus::Removing,
335 Some(ExtensionOperation::Upgrade) => ExtensionStatus::Upgrading,
336 None => match self.extension_index.extensions.get(extension_id) {
337 Some(extension) => ExtensionStatus::Installed(extension.manifest.version.clone()),
338 None => ExtensionStatus::NotInstalled,
339 },
340 }
341 }
342
343 pub fn dev_extensions(&self) -> impl Iterator<Item = &Arc<ExtensionManifest>> {
344 self.extension_index
345 .extensions
346 .values()
347 .filter_map(|extension| extension.dev.then_some(&extension.manifest))
348 }
349
350 pub fn fetch_extensions(
351 &self,
352 search: Option<&str>,
353 cx: &mut ModelContext<Self>,
354 ) -> Task<Result<Vec<ExtensionApiResponse>>> {
355 let url = self.http_client.build_zed_api_url(&format!(
356 "/extensions{query}",
357 query = search
358 .map(|search| format!("?filter={search}"))
359 .unwrap_or_default()
360 ));
361 let http_client = self.http_client.clone();
362 cx.spawn(move |_, _| async move {
363 let mut response = http_client.get(&url, AsyncBody::empty(), true).await?;
364
365 let mut body = Vec::new();
366 response
367 .body_mut()
368 .read_to_end(&mut body)
369 .await
370 .context("error reading extensions")?;
371
372 if response.status().is_client_error() {
373 let text = String::from_utf8_lossy(body.as_slice());
374 bail!(
375 "status error {}, response: {text:?}",
376 response.status().as_u16()
377 );
378 }
379
380 let response: ExtensionsApiResponse = serde_json::from_slice(&body)?;
381
382 Ok(response.data)
383 })
384 }
385
386 pub fn install_extension(
387 &mut self,
388 extension_id: Arc<str>,
389 version: Arc<str>,
390 cx: &mut ModelContext<Self>,
391 ) {
392 self.install_or_upgrade_extension(extension_id, version, ExtensionOperation::Install, cx)
393 }
394
395 pub fn upgrade_extension(
396 &mut self,
397 extension_id: Arc<str>,
398 version: Arc<str>,
399 cx: &mut ModelContext<Self>,
400 ) {
401 self.install_or_upgrade_extension(extension_id, version, ExtensionOperation::Upgrade, cx)
402 }
403
404 fn install_or_upgrade_extension(
405 &mut self,
406 extension_id: Arc<str>,
407 version: Arc<str>,
408 operation: ExtensionOperation,
409 cx: &mut ModelContext<Self>,
410 ) {
411 log::info!("installing extension {extension_id} {version}");
412 let url = self
413 .http_client
414 .build_zed_api_url(&format!("/extensions/{extension_id}/{version}/download"));
415
416 let extensions_dir = self.extensions_dir();
417 let http_client = self.http_client.clone();
418
419 match self.outstanding_operations.entry(extension_id.clone()) {
420 hash_map::Entry::Occupied(_) => return,
421 hash_map::Entry::Vacant(e) => e.insert(operation),
422 };
423
424 cx.spawn(move |this, mut cx| async move {
425 let _finish = util::defer({
426 let this = this.clone();
427 let mut cx = cx.clone();
428 let extension_id = extension_id.clone();
429 move || {
430 this.update(&mut cx, |this, cx| {
431 this.outstanding_operations.remove(extension_id.as_ref());
432 cx.notify();
433 })
434 .ok();
435 }
436 });
437
438 let mut response = http_client
439 .get(&url, Default::default(), true)
440 .await
441 .map_err(|err| anyhow!("error downloading extension: {}", err))?;
442 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
443 let archive = Archive::new(decompressed_bytes);
444 archive
445 .unpack(extensions_dir.join(extension_id.as_ref()))
446 .await?;
447 this.update(&mut cx, |this, _| this.reload(Some(extension_id)))?
448 .await;
449 anyhow::Ok(())
450 })
451 .detach_and_log_err(cx);
452 }
453
454 pub fn uninstall_extension(&mut self, extension_id: Arc<str>, cx: &mut ModelContext<Self>) {
455 let extensions_dir = self.extensions_dir();
456 let fs = self.fs.clone();
457
458 match self.outstanding_operations.entry(extension_id.clone()) {
459 hash_map::Entry::Occupied(_) => return,
460 hash_map::Entry::Vacant(e) => e.insert(ExtensionOperation::Remove),
461 };
462
463 cx.spawn(move |this, mut cx| async move {
464 let _finish = util::defer({
465 let this = this.clone();
466 let mut cx = cx.clone();
467 let extension_id = extension_id.clone();
468 move || {
469 this.update(&mut cx, |this, cx| {
470 this.outstanding_operations.remove(extension_id.as_ref());
471 cx.notify();
472 })
473 .ok();
474 }
475 });
476
477 fs.remove_dir(
478 &extensions_dir.join(extension_id.as_ref()),
479 RemoveOptions {
480 recursive: true,
481 ignore_if_not_exists: true,
482 },
483 )
484 .await?;
485
486 this.update(&mut cx, |this, _| this.reload(None))?.await;
487 anyhow::Ok(())
488 })
489 .detach_and_log_err(cx)
490 }
491
492 pub fn install_dev_extension(
493 &mut self,
494 extension_source_path: PathBuf,
495 cx: &mut ModelContext<Self>,
496 ) {
497 let extensions_dir = self.extensions_dir();
498 let fs = self.fs.clone();
499 let builder = self.builder.clone();
500
501 cx.spawn(move |this, mut cx| async move {
502 let extension_manifest =
503 Self::load_extension_manifest(fs.clone(), &extension_source_path).await?;
504 let extension_id = extension_manifest.id.clone();
505
506 if !this.update(&mut cx, |this, cx| {
507 match this.outstanding_operations.entry(extension_id.clone()) {
508 hash_map::Entry::Occupied(_) => return false,
509 hash_map::Entry::Vacant(e) => e.insert(ExtensionOperation::Remove),
510 };
511 cx.notify();
512 true
513 })? {
514 return Ok(());
515 }
516
517 let _finish = util::defer({
518 let this = this.clone();
519 let mut cx = cx.clone();
520 let extension_id = extension_id.clone();
521 move || {
522 this.update(&mut cx, |this, cx| {
523 this.outstanding_operations.remove(extension_id.as_ref());
524 cx.notify();
525 })
526 .ok();
527 }
528 });
529
530 cx.background_executor()
531 .spawn({
532 let extension_source_path = extension_source_path.clone();
533 async move {
534 builder
535 .compile_extension(
536 &extension_source_path,
537 CompileExtensionOptions { release: true },
538 )
539 .await
540 }
541 })
542 .await?;
543
544 let output_path = &extensions_dir.join(extension_id.as_ref());
545 if let Some(metadata) = fs.metadata(&output_path).await? {
546 if metadata.is_symlink {
547 fs.remove_file(
548 &output_path,
549 RemoveOptions {
550 recursive: false,
551 ignore_if_not_exists: true,
552 },
553 )
554 .await?;
555 } else {
556 bail!("extension {extension_id} is already installed");
557 }
558 }
559
560 fs.create_symlink(output_path, extension_source_path)
561 .await?;
562
563 this.update(&mut cx, |this, _| this.reload(Some(extension_id)))?
564 .await;
565 Ok(())
566 })
567 .detach_and_log_err(cx)
568 }
569
570 pub fn rebuild_dev_extension(&mut self, extension_id: Arc<str>, cx: &mut ModelContext<Self>) {
571 let path = self.installed_dir.join(extension_id.as_ref());
572 let builder = self.builder.clone();
573
574 match self.outstanding_operations.entry(extension_id.clone()) {
575 hash_map::Entry::Occupied(_) => return,
576 hash_map::Entry::Vacant(e) => e.insert(ExtensionOperation::Upgrade),
577 };
578
579 cx.notify();
580 let compile = cx.background_executor().spawn(async move {
581 builder
582 .compile_extension(&path, CompileExtensionOptions { release: true })
583 .await
584 });
585
586 cx.spawn(|this, mut cx| async move {
587 let result = compile.await;
588
589 this.update(&mut cx, |this, cx| {
590 this.outstanding_operations.remove(&extension_id);
591 cx.notify();
592 })?;
593
594 if result.is_ok() {
595 this.update(&mut cx, |this, _| this.reload(Some(extension_id)))?
596 .await;
597 }
598
599 result
600 })
601 .detach_and_log_err(cx)
602 }
603
604 /// Updates the set of installed extensions.
605 ///
606 /// First, this unloads any themes, languages, or grammars that are
607 /// no longer in the manifest, or whose files have changed on disk.
608 /// Then it loads any themes, languages, or grammars that are newly
609 /// added to the manifest, or whose files have changed on disk.
610 fn extensions_updated(
611 &mut self,
612 new_index: ExtensionIndex,
613 cx: &mut ModelContext<Self>,
614 ) -> Task<()> {
615 let old_index = &self.extension_index;
616
617 // Determine which extensions need to be loaded and unloaded, based
618 // on the changes to the manifest and the extensions that we know have been
619 // modified.
620 let mut extensions_to_unload = Vec::default();
621 let mut extensions_to_load = Vec::default();
622 {
623 let mut old_keys = old_index.extensions.iter().peekable();
624 let mut new_keys = new_index.extensions.iter().peekable();
625 loop {
626 match (old_keys.peek(), new_keys.peek()) {
627 (None, None) => break,
628 (None, Some(_)) => {
629 extensions_to_load.push(new_keys.next().unwrap().0.clone());
630 }
631 (Some(_), None) => {
632 extensions_to_unload.push(old_keys.next().unwrap().0.clone());
633 }
634 (Some((old_key, _)), Some((new_key, _))) => match old_key.cmp(&new_key) {
635 Ordering::Equal => {
636 let (old_key, old_value) = old_keys.next().unwrap();
637 let (new_key, new_value) = new_keys.next().unwrap();
638 if old_value != new_value || self.modified_extensions.contains(old_key)
639 {
640 extensions_to_unload.push(old_key.clone());
641 extensions_to_load.push(new_key.clone());
642 }
643 }
644 Ordering::Less => {
645 extensions_to_unload.push(old_keys.next().unwrap().0.clone());
646 }
647 Ordering::Greater => {
648 extensions_to_load.push(new_keys.next().unwrap().0.clone());
649 }
650 },
651 }
652 }
653 self.modified_extensions.clear();
654 }
655
656 if extensions_to_load.is_empty() && extensions_to_unload.is_empty() {
657 return Task::ready(());
658 }
659
660 let reload_count = extensions_to_unload
661 .iter()
662 .filter(|id| extensions_to_load.contains(id))
663 .count();
664
665 log::info!(
666 "extensions updated. loading {}, reloading {}, unloading {}",
667 extensions_to_unload.len() - reload_count,
668 reload_count,
669 extensions_to_load.len() - reload_count
670 );
671
672 let themes_to_remove = old_index
673 .themes
674 .iter()
675 .filter_map(|(name, entry)| {
676 if extensions_to_unload.contains(&entry.extension) {
677 Some(name.clone().into())
678 } else {
679 None
680 }
681 })
682 .collect::<Vec<_>>();
683 let languages_to_remove = old_index
684 .languages
685 .iter()
686 .filter_map(|(name, entry)| {
687 if extensions_to_unload.contains(&entry.extension) {
688 Some(name.clone())
689 } else {
690 None
691 }
692 })
693 .collect::<Vec<_>>();
694 let mut grammars_to_remove = Vec::new();
695 for extension_id in &extensions_to_unload {
696 let Some(extension) = old_index.extensions.get(extension_id) else {
697 continue;
698 };
699 grammars_to_remove.extend(extension.manifest.grammars.keys().cloned());
700 for (language_server_name, config) in extension.manifest.language_servers.iter() {
701 self.language_registry
702 .remove_lsp_adapter(config.language.as_ref(), language_server_name);
703 }
704 }
705
706 self.wasm_extensions
707 .retain(|(extension, _)| !extensions_to_unload.contains(&extension.id));
708 self.theme_registry.remove_user_themes(&themes_to_remove);
709 self.language_registry
710 .remove_languages(&languages_to_remove, &grammars_to_remove);
711
712 let languages_to_add = new_index
713 .languages
714 .iter()
715 .filter(|(_, entry)| extensions_to_load.contains(&entry.extension))
716 .collect::<Vec<_>>();
717 let mut grammars_to_add = Vec::new();
718 let mut themes_to_add = Vec::new();
719 for extension_id in &extensions_to_load {
720 let Some(extension) = new_index.extensions.get(extension_id) else {
721 continue;
722 };
723
724 grammars_to_add.extend(extension.manifest.grammars.keys().map(|grammar_name| {
725 let mut grammar_path = self.installed_dir.clone();
726 grammar_path.extend([extension_id.as_ref(), "grammars"]);
727 grammar_path.push(grammar_name.as_ref());
728 grammar_path.set_extension("wasm");
729 (grammar_name.clone(), grammar_path)
730 }));
731 themes_to_add.extend(extension.manifest.themes.iter().map(|theme_path| {
732 let mut path = self.installed_dir.clone();
733 path.extend([Path::new(extension_id.as_ref()), theme_path.as_path()]);
734 path
735 }));
736 }
737
738 self.language_registry
739 .register_wasm_grammars(grammars_to_add);
740
741 for (language_name, language) in languages_to_add {
742 let mut language_path = self.installed_dir.clone();
743 language_path.extend([
744 Path::new(language.extension.as_ref()),
745 language.path.as_path(),
746 ]);
747 self.language_registry.register_language(
748 language_name.clone(),
749 language.grammar.clone(),
750 language.matcher.clone(),
751 None,
752 move || {
753 let config = std::fs::read_to_string(language_path.join("config.toml"))?;
754 let config: LanguageConfig = ::toml::from_str(&config)?;
755 let queries = load_plugin_queries(&language_path);
756 Ok((config, queries))
757 },
758 );
759 }
760
761 let fs = self.fs.clone();
762 let wasm_host = self.wasm_host.clone();
763 let root_dir = self.installed_dir.clone();
764 let theme_registry = self.theme_registry.clone();
765 let extension_entries = extensions_to_load
766 .iter()
767 .filter_map(|name| new_index.extensions.get(name).cloned())
768 .collect::<Vec<_>>();
769
770 self.extension_index = new_index;
771 cx.notify();
772 cx.emit(Event::ExtensionsUpdated);
773
774 cx.spawn(|this, mut cx| async move {
775 cx.background_executor()
776 .spawn({
777 let fs = fs.clone();
778 async move {
779 for theme_path in &themes_to_add {
780 theme_registry
781 .load_user_theme(&theme_path, fs.clone())
782 .await
783 .log_err();
784 }
785 }
786 })
787 .await;
788
789 let mut wasm_extensions = Vec::new();
790 for extension in extension_entries {
791 if extension.manifest.lib.kind.is_none() {
792 continue;
793 };
794
795 let mut path = root_dir.clone();
796 path.extend([extension.manifest.id.as_ref(), "extension.wasm"]);
797 let Some(mut wasm_file) = fs
798 .open_sync(&path)
799 .await
800 .context("failed to open wasm file")
801 .log_err()
802 else {
803 continue;
804 };
805
806 let mut wasm_bytes = Vec::new();
807 if wasm_file
808 .read_to_end(&mut wasm_bytes)
809 .context("failed to read wasm")
810 .log_err()
811 .is_none()
812 {
813 continue;
814 }
815
816 let Some(wasm_extension) = wasm_host
817 .load_extension(
818 wasm_bytes,
819 extension.manifest.clone(),
820 cx.background_executor().clone(),
821 )
822 .await
823 .context("failed to load wasm extension")
824 .log_err()
825 else {
826 continue;
827 };
828
829 wasm_extensions.push((extension.manifest.clone(), wasm_extension));
830 }
831
832 this.update(&mut cx, |this, cx| {
833 this.reload_complete_senders.clear();
834
835 for (manifest, wasm_extension) in &wasm_extensions {
836 for (language_server_name, language_server_config) in &manifest.language_servers
837 {
838 this.language_registry.register_lsp_adapter(
839 language_server_config.language.clone(),
840 Arc::new(ExtensionLspAdapter {
841 extension: wasm_extension.clone(),
842 work_dir: this.wasm_host.work_dir.join(manifest.id.as_ref()),
843 config: wit::LanguageServerConfig {
844 name: language_server_name.0.to_string(),
845 language_name: language_server_config.language.to_string(),
846 },
847 }),
848 );
849 }
850 }
851 this.wasm_extensions.extend(wasm_extensions);
852 ThemeSettings::reload_current_theme(cx)
853 })
854 .ok();
855 })
856 }
857
858 fn rebuild_extension_index(&self, cx: &mut ModelContext<Self>) -> Task<ExtensionIndex> {
859 let fs = self.fs.clone();
860 let work_dir = self.wasm_host.work_dir.clone();
861 let extensions_dir = self.installed_dir.clone();
862 let index_path = self.index_path.clone();
863 cx.background_executor().spawn(async move {
864 let start_time = Instant::now();
865 let mut index = ExtensionIndex::default();
866
867 fs.create_dir(&work_dir).await.log_err();
868 fs.create_dir(&extensions_dir).await.log_err();
869
870 let extension_paths = fs.read_dir(&extensions_dir).await;
871 if let Ok(mut extension_paths) = extension_paths {
872 while let Some(extension_dir) = extension_paths.next().await {
873 let Ok(extension_dir) = extension_dir else {
874 continue;
875 };
876 Self::add_extension_to_index(fs.clone(), extension_dir, &mut index)
877 .await
878 .log_err();
879 }
880 }
881
882 if let Ok(index_json) = serde_json::to_string_pretty(&index) {
883 fs.save(&index_path, &index_json.as_str().into(), Default::default())
884 .await
885 .context("failed to save extension index")
886 .log_err();
887 }
888
889 log::info!("rebuilt extension index in {:?}", start_time.elapsed());
890 index
891 })
892 }
893
894 async fn add_extension_to_index(
895 fs: Arc<dyn Fs>,
896 extension_dir: PathBuf,
897 index: &mut ExtensionIndex,
898 ) -> Result<()> {
899 let mut extension_manifest =
900 Self::load_extension_manifest(fs.clone(), &extension_dir).await?;
901 let extension_id = extension_manifest.id.clone();
902
903 // TODO: distinguish dev extensions more explicitly, by the absence
904 // of a checksum file that we'll create when downloading normal extensions.
905 let is_dev = fs
906 .metadata(&extension_dir)
907 .await?
908 .ok_or_else(|| anyhow!("directory does not exist"))?
909 .is_symlink;
910
911 if let Ok(mut language_paths) = fs.read_dir(&extension_dir.join("languages")).await {
912 while let Some(language_path) = language_paths.next().await {
913 let language_path = language_path?;
914 let Ok(relative_path) = language_path.strip_prefix(&extension_dir) else {
915 continue;
916 };
917 let Ok(Some(fs_metadata)) = fs.metadata(&language_path).await else {
918 continue;
919 };
920 if !fs_metadata.is_dir {
921 continue;
922 }
923 let config = fs.load(&language_path.join("config.toml")).await?;
924 let config = ::toml::from_str::<LanguageConfig>(&config)?;
925
926 let relative_path = relative_path.to_path_buf();
927 if !extension_manifest.languages.contains(&relative_path) {
928 extension_manifest.languages.push(relative_path.clone());
929 }
930
931 index.languages.insert(
932 config.name.clone(),
933 ExtensionIndexLanguageEntry {
934 extension: extension_id.clone(),
935 path: relative_path,
936 matcher: config.matcher,
937 grammar: config.grammar,
938 },
939 );
940 }
941 }
942
943 if let Ok(mut theme_paths) = fs.read_dir(&extension_dir.join("themes")).await {
944 while let Some(theme_path) = theme_paths.next().await {
945 let theme_path = theme_path?;
946 let Ok(relative_path) = theme_path.strip_prefix(&extension_dir) else {
947 continue;
948 };
949
950 let Some(theme_family) = ThemeRegistry::read_user_theme(&theme_path, fs.clone())
951 .await
952 .log_err()
953 else {
954 continue;
955 };
956
957 let relative_path = relative_path.to_path_buf();
958 if !extension_manifest.themes.contains(&relative_path) {
959 extension_manifest.themes.push(relative_path.clone());
960 }
961
962 for theme in theme_family.themes {
963 index.themes.insert(
964 theme.name.into(),
965 ExtensionIndexThemeEntry {
966 extension: extension_id.clone(),
967 path: relative_path.clone(),
968 },
969 );
970 }
971 }
972 }
973
974 let extension_wasm_path = extension_dir.join("extension.wasm");
975 if fs.is_file(&extension_wasm_path).await {
976 extension_manifest
977 .lib
978 .kind
979 .get_or_insert(ExtensionLibraryKind::Rust);
980 }
981
982 index.extensions.insert(
983 extension_id.clone(),
984 ExtensionIndexEntry {
985 dev: is_dev,
986 manifest: Arc::new(extension_manifest),
987 },
988 );
989
990 Ok(())
991 }
992
993 async fn load_extension_manifest(
994 fs: Arc<dyn Fs>,
995 extension_dir: &Path,
996 ) -> Result<ExtensionManifest> {
997 let extension_name = extension_dir
998 .file_name()
999 .and_then(OsStr::to_str)
1000 .ok_or_else(|| anyhow!("invalid extension name"))?;
1001
1002 let mut extension_manifest_path = extension_dir.join("extension.json");
1003 if fs.is_file(&extension_manifest_path).await {
1004 let manifest_content = fs
1005 .load(&extension_manifest_path)
1006 .await
1007 .with_context(|| format!("failed to load {extension_name} extension.json"))?;
1008 let manifest_json = serde_json::from_str::<OldExtensionManifest>(&manifest_content)
1009 .with_context(|| {
1010 format!("invalid extension.json for extension {extension_name}")
1011 })?;
1012
1013 Ok(manifest_from_old_manifest(manifest_json, extension_name))
1014 } else {
1015 extension_manifest_path.set_extension("toml");
1016 let manifest_content = fs
1017 .load(&extension_manifest_path)
1018 .await
1019 .with_context(|| format!("failed to load {extension_name} extension.toml"))?;
1020 toml::from_str(&manifest_content)
1021 .with_context(|| format!("invalid extension.json for extension {extension_name}"))
1022 }
1023 }
1024}
1025
1026fn manifest_from_old_manifest(
1027 manifest_json: OldExtensionManifest,
1028 extension_id: &str,
1029) -> ExtensionManifest {
1030 ExtensionManifest {
1031 id: extension_id.into(),
1032 name: manifest_json.name,
1033 version: manifest_json.version,
1034 description: manifest_json.description,
1035 repository: manifest_json.repository,
1036 authors: manifest_json.authors,
1037 lib: Default::default(),
1038 themes: {
1039 let mut themes = manifest_json.themes.into_values().collect::<Vec<_>>();
1040 themes.sort();
1041 themes.dedup();
1042 themes
1043 },
1044 languages: {
1045 let mut languages = manifest_json.languages.into_values().collect::<Vec<_>>();
1046 languages.sort();
1047 languages.dedup();
1048 languages
1049 },
1050 grammars: manifest_json
1051 .grammars
1052 .into_keys()
1053 .map(|grammar_name| (grammar_name, Default::default()))
1054 .collect(),
1055 language_servers: Default::default(),
1056 }
1057}
1058
1059fn load_plugin_queries(root_path: &Path) -> LanguageQueries {
1060 let mut result = LanguageQueries::default();
1061 if let Some(entries) = std::fs::read_dir(root_path).log_err() {
1062 for entry in entries {
1063 let Some(entry) = entry.log_err() else {
1064 continue;
1065 };
1066 let path = entry.path();
1067 if let Some(remainder) = path.strip_prefix(root_path).ok().and_then(|p| p.to_str()) {
1068 if !remainder.ends_with(".scm") {
1069 continue;
1070 }
1071 for (name, query) in QUERY_FILENAME_PREFIXES {
1072 if remainder.starts_with(name) {
1073 if let Some(contents) = std::fs::read_to_string(&path).log_err() {
1074 match query(&mut result) {
1075 None => *query(&mut result) = Some(contents.into()),
1076 Some(r) => r.to_mut().push_str(contents.as_ref()),
1077 }
1078 }
1079 break;
1080 }
1081 }
1082 }
1083 }
1084 }
1085 result
1086}