1pub mod wit;
2
3use crate::ExtensionManifest;
4use anyhow::{Context as _, Result, anyhow, bail};
5use async_trait::async_trait;
6use dap::{DebugRequest, StartDebuggingRequestArgumentsRequest};
7use extension::{
8 CodeLabel, Command, Completion, ContextServerConfiguration, DebugAdapterBinary,
9 DebugTaskDefinition, ExtensionHostProxy, KeyValueStoreDelegate, ProjectDelegate, SlashCommand,
10 SlashCommandArgumentCompletion, SlashCommandOutput, Symbol, WorktreeDelegate,
11};
12use fs::{Fs, normalize_path};
13use futures::future::LocalBoxFuture;
14use futures::{
15 Future, FutureExt, StreamExt as _,
16 channel::{
17 mpsc::{self, UnboundedSender},
18 oneshot,
19 },
20 future::BoxFuture,
21};
22use gpui::{App, AsyncApp, BackgroundExecutor, Task};
23use http_client::HttpClient;
24use language::LanguageName;
25use lsp::LanguageServerName;
26use moka::sync::Cache;
27use node_runtime::NodeRuntime;
28use release_channel::ReleaseChannel;
29use semantic_version::SemanticVersion;
30use std::borrow::Cow;
31use std::sync::LazyLock;
32use std::{
33 path::{Path, PathBuf},
34 sync::Arc,
35};
36use task::{DebugScenario, SpawnInTerminal, TaskTemplate, ZedDebugConfig};
37use wasmtime::{
38 CacheStore, Engine, Store,
39 component::{Component, ResourceTable},
40};
41use wasmtime_wasi::{self as wasi, WasiView};
42use wit::Extension;
43
44pub struct WasmHost {
45 engine: Engine,
46 release_channel: ReleaseChannel,
47 http_client: Arc<dyn HttpClient>,
48 node_runtime: NodeRuntime,
49 pub(crate) proxy: Arc<ExtensionHostProxy>,
50 fs: Arc<dyn Fs>,
51 pub work_dir: PathBuf,
52 _main_thread_message_task: Task<()>,
53 main_thread_message_tx: mpsc::UnboundedSender<MainThreadCall>,
54}
55
56#[derive(Clone)]
57pub struct WasmExtension {
58 tx: UnboundedSender<ExtensionCall>,
59 pub manifest: Arc<ExtensionManifest>,
60 pub work_dir: Arc<Path>,
61 #[allow(unused)]
62 pub zed_api_version: SemanticVersion,
63}
64
65#[async_trait]
66impl extension::Extension for WasmExtension {
67 fn manifest(&self) -> Arc<ExtensionManifest> {
68 self.manifest.clone()
69 }
70
71 fn work_dir(&self) -> Arc<Path> {
72 self.work_dir.clone()
73 }
74
75 async fn language_server_command(
76 &self,
77 language_server_id: LanguageServerName,
78 language_name: LanguageName,
79 worktree: Arc<dyn WorktreeDelegate>,
80 ) -> Result<Command> {
81 self.call(|extension, store| {
82 async move {
83 let resource = store.data_mut().table().push(worktree)?;
84 let command = extension
85 .call_language_server_command(
86 store,
87 &language_server_id,
88 &language_name,
89 resource,
90 )
91 .await?
92 .map_err(|err| store.data().extension_error(err))?;
93
94 Ok(command.into())
95 }
96 .boxed()
97 })
98 .await
99 }
100
101 async fn language_server_initialization_options(
102 &self,
103 language_server_id: LanguageServerName,
104 language_name: LanguageName,
105 worktree: Arc<dyn WorktreeDelegate>,
106 ) -> Result<Option<String>> {
107 self.call(|extension, store| {
108 async move {
109 let resource = store.data_mut().table().push(worktree)?;
110 let options = extension
111 .call_language_server_initialization_options(
112 store,
113 &language_server_id,
114 &language_name,
115 resource,
116 )
117 .await?
118 .map_err(|err| store.data().extension_error(err))?;
119 anyhow::Ok(options)
120 }
121 .boxed()
122 })
123 .await
124 }
125
126 async fn language_server_workspace_configuration(
127 &self,
128 language_server_id: LanguageServerName,
129 worktree: Arc<dyn WorktreeDelegate>,
130 ) -> Result<Option<String>> {
131 self.call(|extension, store| {
132 async move {
133 let resource = store.data_mut().table().push(worktree)?;
134 let options = extension
135 .call_language_server_workspace_configuration(
136 store,
137 &language_server_id,
138 resource,
139 )
140 .await?
141 .map_err(|err| store.data().extension_error(err))?;
142 anyhow::Ok(options)
143 }
144 .boxed()
145 })
146 .await
147 }
148
149 async fn language_server_additional_initialization_options(
150 &self,
151 language_server_id: LanguageServerName,
152 target_language_server_id: LanguageServerName,
153 worktree: Arc<dyn WorktreeDelegate>,
154 ) -> Result<Option<String>> {
155 self.call(|extension, store| {
156 async move {
157 let resource = store.data_mut().table().push(worktree)?;
158 let options = extension
159 .call_language_server_additional_initialization_options(
160 store,
161 &language_server_id,
162 &target_language_server_id,
163 resource,
164 )
165 .await?
166 .map_err(|err| store.data().extension_error(err))?;
167 anyhow::Ok(options)
168 }
169 .boxed()
170 })
171 .await
172 }
173
174 async fn language_server_additional_workspace_configuration(
175 &self,
176 language_server_id: LanguageServerName,
177 target_language_server_id: LanguageServerName,
178 worktree: Arc<dyn WorktreeDelegate>,
179 ) -> Result<Option<String>> {
180 self.call(|extension, store| {
181 async move {
182 let resource = store.data_mut().table().push(worktree)?;
183 let options = extension
184 .call_language_server_additional_workspace_configuration(
185 store,
186 &language_server_id,
187 &target_language_server_id,
188 resource,
189 )
190 .await?
191 .map_err(|err| store.data().extension_error(err))?;
192 anyhow::Ok(options)
193 }
194 .boxed()
195 })
196 .await
197 }
198
199 async fn labels_for_completions(
200 &self,
201 language_server_id: LanguageServerName,
202 completions: Vec<Completion>,
203 ) -> Result<Vec<Option<CodeLabel>>> {
204 self.call(|extension, store| {
205 async move {
206 let labels = extension
207 .call_labels_for_completions(
208 store,
209 &language_server_id,
210 completions.into_iter().map(Into::into).collect(),
211 )
212 .await?
213 .map_err(|err| store.data().extension_error(err))?;
214
215 Ok(labels
216 .into_iter()
217 .map(|label| label.map(Into::into))
218 .collect())
219 }
220 .boxed()
221 })
222 .await
223 }
224
225 async fn labels_for_symbols(
226 &self,
227 language_server_id: LanguageServerName,
228 symbols: Vec<Symbol>,
229 ) -> Result<Vec<Option<CodeLabel>>> {
230 self.call(|extension, store| {
231 async move {
232 let labels = extension
233 .call_labels_for_symbols(
234 store,
235 &language_server_id,
236 symbols.into_iter().map(Into::into).collect(),
237 )
238 .await?
239 .map_err(|err| store.data().extension_error(err))?;
240
241 Ok(labels
242 .into_iter()
243 .map(|label| label.map(Into::into))
244 .collect())
245 }
246 .boxed()
247 })
248 .await
249 }
250
251 async fn complete_slash_command_argument(
252 &self,
253 command: SlashCommand,
254 arguments: Vec<String>,
255 ) -> Result<Vec<SlashCommandArgumentCompletion>> {
256 self.call(|extension, store| {
257 async move {
258 let completions = extension
259 .call_complete_slash_command_argument(store, &command.into(), &arguments)
260 .await?
261 .map_err(|err| store.data().extension_error(err))?;
262
263 Ok(completions.into_iter().map(Into::into).collect())
264 }
265 .boxed()
266 })
267 .await
268 }
269
270 async fn run_slash_command(
271 &self,
272 command: SlashCommand,
273 arguments: Vec<String>,
274 delegate: Option<Arc<dyn WorktreeDelegate>>,
275 ) -> Result<SlashCommandOutput> {
276 self.call(|extension, store| {
277 async move {
278 let resource = if let Some(delegate) = delegate {
279 Some(store.data_mut().table().push(delegate)?)
280 } else {
281 None
282 };
283
284 let output = extension
285 .call_run_slash_command(store, &command.into(), &arguments, resource)
286 .await?
287 .map_err(|err| store.data().extension_error(err))?;
288
289 Ok(output.into())
290 }
291 .boxed()
292 })
293 .await
294 }
295
296 async fn context_server_command(
297 &self,
298 context_server_id: Arc<str>,
299 project: Arc<dyn ProjectDelegate>,
300 ) -> Result<Command> {
301 self.call(|extension, store| {
302 async move {
303 let project_resource = store.data_mut().table().push(project)?;
304 let command = extension
305 .call_context_server_command(store, context_server_id.clone(), project_resource)
306 .await?
307 .map_err(|err| store.data().extension_error(err))?;
308 anyhow::Ok(command.into())
309 }
310 .boxed()
311 })
312 .await
313 }
314
315 async fn context_server_configuration(
316 &self,
317 context_server_id: Arc<str>,
318 project: Arc<dyn ProjectDelegate>,
319 ) -> Result<Option<ContextServerConfiguration>> {
320 self.call(|extension, store| {
321 async move {
322 let project_resource = store.data_mut().table().push(project)?;
323 let Some(configuration) = extension
324 .call_context_server_configuration(
325 store,
326 context_server_id.clone(),
327 project_resource,
328 )
329 .await?
330 .map_err(|err| store.data().extension_error(err))?
331 else {
332 return Ok(None);
333 };
334
335 Ok(Some(configuration.try_into()?))
336 }
337 .boxed()
338 })
339 .await
340 }
341
342 async fn suggest_docs_packages(&self, provider: Arc<str>) -> Result<Vec<String>> {
343 self.call(|extension, store| {
344 async move {
345 let packages = extension
346 .call_suggest_docs_packages(store, provider.as_ref())
347 .await?
348 .map_err(|err| store.data().extension_error(err))?;
349
350 Ok(packages)
351 }
352 .boxed()
353 })
354 .await
355 }
356
357 async fn index_docs(
358 &self,
359 provider: Arc<str>,
360 package_name: Arc<str>,
361 kv_store: Arc<dyn KeyValueStoreDelegate>,
362 ) -> Result<()> {
363 self.call(|extension, store| {
364 async move {
365 let kv_store_resource = store.data_mut().table().push(kv_store)?;
366 extension
367 .call_index_docs(
368 store,
369 provider.as_ref(),
370 package_name.as_ref(),
371 kv_store_resource,
372 )
373 .await?
374 .map_err(|err| store.data().extension_error(err))?;
375
376 anyhow::Ok(())
377 }
378 .boxed()
379 })
380 .await
381 }
382
383 async fn get_dap_binary(
384 &self,
385 dap_name: Arc<str>,
386 config: DebugTaskDefinition,
387 user_installed_path: Option<PathBuf>,
388 worktree: Arc<dyn WorktreeDelegate>,
389 ) -> Result<DebugAdapterBinary> {
390 self.call(|extension, store| {
391 async move {
392 let resource = store.data_mut().table().push(worktree)?;
393 let dap_binary = extension
394 .call_get_dap_binary(store, dap_name, config, user_installed_path, resource)
395 .await?
396 .map_err(|err| store.data().extension_error(err))?;
397 let dap_binary = dap_binary.try_into()?;
398 Ok(dap_binary)
399 }
400 .boxed()
401 })
402 .await
403 }
404 async fn dap_request_kind(
405 &self,
406 dap_name: Arc<str>,
407 config: serde_json::Value,
408 ) -> Result<StartDebuggingRequestArgumentsRequest> {
409 self.call(|extension, store| {
410 async move {
411 let kind = extension
412 .call_dap_request_kind(store, dap_name, config)
413 .await?
414 .map_err(|err| store.data().extension_error(err))?;
415 Ok(kind.into())
416 }
417 .boxed()
418 })
419 .await
420 }
421
422 async fn dap_config_to_scenario(
423 &self,
424 config: ZedDebugConfig,
425 worktree: Arc<dyn WorktreeDelegate>,
426 ) -> Result<DebugScenario> {
427 self.call(|extension, store| {
428 async move {
429 let resource = store.data_mut().table().push(worktree)?;
430 let kind = extension
431 .call_dap_config_to_scenario(store, config, resource)
432 .await?
433 .map_err(|err| store.data().extension_error(err))?;
434 Ok(kind)
435 }
436 .boxed()
437 })
438 .await
439 }
440
441 async fn dap_locator_create_scenario(
442 &self,
443 locator_name: String,
444 build_config_template: TaskTemplate,
445 resolved_label: String,
446 debug_adapter_name: String,
447 ) -> Result<Option<DebugScenario>> {
448 self.call(|extension, store| {
449 async move {
450 extension
451 .call_dap_locator_create_scenario(
452 store,
453 locator_name,
454 build_config_template,
455 resolved_label,
456 debug_adapter_name,
457 )
458 .await
459 }
460 .boxed()
461 })
462 .await
463 }
464 async fn run_dap_locator(
465 &self,
466 locator_name: String,
467 config: SpawnInTerminal,
468 ) -> Result<DebugRequest> {
469 self.call(|extension, store| {
470 async move {
471 extension
472 .call_run_dap_locator(store, locator_name, config)
473 .await?
474 .map_err(|err| store.data().extension_error(err))
475 }
476 .boxed()
477 })
478 .await
479 }
480}
481
482pub struct WasmState {
483 manifest: Arc<ExtensionManifest>,
484 pub table: ResourceTable,
485 ctx: wasi::WasiCtx,
486 pub host: Arc<WasmHost>,
487}
488
489type MainThreadCall = Box<dyn Send + for<'a> FnOnce(&'a mut AsyncApp) -> LocalBoxFuture<'a, ()>>;
490
491type ExtensionCall = Box<
492 dyn Send + for<'a> FnOnce(&'a mut Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, ()>,
493>;
494
495fn wasm_engine() -> wasmtime::Engine {
496 static WASM_ENGINE: LazyLock<wasmtime::Engine> = LazyLock::new(|| {
497 let mut config = wasmtime::Config::new();
498 config.wasm_component_model(true);
499 config.async_support(true);
500 config
501 .enable_incremental_compilation(cache_store())
502 .unwrap();
503 wasmtime::Engine::new(&config).unwrap()
504 });
505
506 WASM_ENGINE.clone()
507}
508
509fn cache_store() -> Arc<IncrementalCompilationCache> {
510 static CACHE_STORE: LazyLock<Arc<IncrementalCompilationCache>> =
511 LazyLock::new(|| Arc::new(IncrementalCompilationCache::new()));
512 CACHE_STORE.clone()
513}
514
515impl WasmHost {
516 pub fn new(
517 fs: Arc<dyn Fs>,
518 http_client: Arc<dyn HttpClient>,
519 node_runtime: NodeRuntime,
520 proxy: Arc<ExtensionHostProxy>,
521 work_dir: PathBuf,
522 cx: &mut App,
523 ) -> Arc<Self> {
524 let (tx, mut rx) = mpsc::unbounded::<MainThreadCall>();
525 let task = cx.spawn(async move |cx| {
526 while let Some(message) = rx.next().await {
527 message(cx).await;
528 }
529 });
530 Arc::new(Self {
531 engine: wasm_engine(),
532 fs,
533 work_dir,
534 http_client,
535 node_runtime,
536 proxy,
537 release_channel: ReleaseChannel::global(cx),
538 _main_thread_message_task: task,
539 main_thread_message_tx: tx,
540 })
541 }
542
543 pub fn load_extension(
544 self: &Arc<Self>,
545 wasm_bytes: Vec<u8>,
546 manifest: &Arc<ExtensionManifest>,
547 executor: BackgroundExecutor,
548 ) -> Task<Result<WasmExtension>> {
549 let this = self.clone();
550 let manifest = manifest.clone();
551 executor.clone().spawn(async move {
552 let zed_api_version = parse_wasm_extension_version(&manifest.id, &wasm_bytes)?;
553
554 let component = Component::from_binary(&this.engine, &wasm_bytes)
555 .context("failed to compile wasm component")?;
556
557 let mut store = wasmtime::Store::new(
558 &this.engine,
559 WasmState {
560 ctx: this.build_wasi_ctx(&manifest).await?,
561 manifest: manifest.clone(),
562 table: ResourceTable::new(),
563 host: this.clone(),
564 },
565 );
566
567 let mut extension = Extension::instantiate_async(
568 &mut store,
569 this.release_channel,
570 zed_api_version,
571 &component,
572 )
573 .await?;
574
575 extension
576 .call_init_extension(&mut store)
577 .await
578 .context("failed to initialize wasm extension")?;
579
580 let (tx, mut rx) = mpsc::unbounded::<ExtensionCall>();
581 executor
582 .spawn(async move {
583 while let Some(call) = rx.next().await {
584 (call)(&mut extension, &mut store).await;
585 }
586 })
587 .detach();
588
589 Ok(WasmExtension {
590 manifest: manifest.clone(),
591 work_dir: this.work_dir.join(manifest.id.as_ref()).into(),
592 tx,
593 zed_api_version,
594 })
595 })
596 }
597
598 async fn build_wasi_ctx(&self, manifest: &Arc<ExtensionManifest>) -> Result<wasi::WasiCtx> {
599 let extension_work_dir = self.work_dir.join(manifest.id.as_ref());
600 self.fs
601 .create_dir(&extension_work_dir)
602 .await
603 .context("failed to create extension work dir")?;
604
605 let file_perms = wasi::FilePerms::all();
606 let dir_perms = wasi::DirPerms::all();
607
608 Ok(wasi::WasiCtxBuilder::new()
609 .inherit_stdio()
610 .preopened_dir(&extension_work_dir, ".", dir_perms, file_perms)?
611 .preopened_dir(
612 &extension_work_dir,
613 extension_work_dir.to_string_lossy(),
614 dir_perms,
615 file_perms,
616 )?
617 .env("PWD", extension_work_dir.to_string_lossy())
618 .env("RUST_BACKTRACE", "full")
619 .build())
620 }
621
622 pub fn writeable_path_from_extension(&self, id: &Arc<str>, path: &Path) -> Result<PathBuf> {
623 let extension_work_dir = self.work_dir.join(id.as_ref());
624 let path = normalize_path(&extension_work_dir.join(path));
625 anyhow::ensure!(
626 path.starts_with(&extension_work_dir),
627 "cannot write to path {path:?}",
628 );
629 Ok(path)
630 }
631}
632
633pub fn parse_wasm_extension_version(
634 extension_id: &str,
635 wasm_bytes: &[u8],
636) -> Result<SemanticVersion> {
637 let mut version = None;
638
639 for part in wasmparser::Parser::new(0).parse_all(wasm_bytes) {
640 if let wasmparser::Payload::CustomSection(s) =
641 part.context("error parsing wasm extension")?
642 {
643 if s.name() == "zed:api-version" {
644 version = parse_wasm_extension_version_custom_section(s.data());
645 if version.is_none() {
646 bail!(
647 "extension {} has invalid zed:api-version section: {:?}",
648 extension_id,
649 s.data()
650 );
651 }
652 }
653 }
654 }
655
656 // The reason we wait until we're done parsing all of the Wasm bytes to return the version
657 // is to work around a panic that can happen inside of Wasmtime when the bytes are invalid.
658 //
659 // By parsing the entirety of the Wasm bytes before we return, we're able to detect this problem
660 // earlier as an `Err` rather than as a panic.
661 version.with_context(|| format!("extension {extension_id} has no zed:api-version section"))
662}
663
664fn parse_wasm_extension_version_custom_section(data: &[u8]) -> Option<SemanticVersion> {
665 if data.len() == 6 {
666 Some(SemanticVersion::new(
667 u16::from_be_bytes([data[0], data[1]]) as _,
668 u16::from_be_bytes([data[2], data[3]]) as _,
669 u16::from_be_bytes([data[4], data[5]]) as _,
670 ))
671 } else {
672 None
673 }
674}
675
676impl WasmExtension {
677 pub async fn load(
678 extension_dir: PathBuf,
679 manifest: &Arc<ExtensionManifest>,
680 wasm_host: Arc<WasmHost>,
681 cx: &AsyncApp,
682 ) -> Result<Self> {
683 let path = extension_dir.join("extension.wasm");
684
685 let mut wasm_file = wasm_host
686 .fs
687 .open_sync(&path)
688 .await
689 .context("failed to open wasm file")?;
690
691 let mut wasm_bytes = Vec::new();
692 wasm_file
693 .read_to_end(&mut wasm_bytes)
694 .context("failed to read wasm")?;
695
696 wasm_host
697 .load_extension(wasm_bytes, manifest, cx.background_executor().clone())
698 .await
699 .with_context(|| format!("failed to load wasm extension {}", manifest.id))
700 }
701
702 pub async fn call<T, Fn>(&self, f: Fn) -> T
703 where
704 T: 'static + Send,
705 Fn: 'static
706 + Send
707 + for<'a> FnOnce(&'a mut Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, T>,
708 {
709 let (return_tx, return_rx) = oneshot::channel();
710 self.tx
711 .clone()
712 .unbounded_send(Box::new(move |extension, store| {
713 async {
714 let result = f(extension, store).await;
715 return_tx.send(result).ok();
716 }
717 .boxed()
718 }))
719 .expect("wasm extension channel should not be closed yet");
720 return_rx.await.expect("wasm extension channel")
721 }
722}
723
724impl WasmState {
725 fn on_main_thread<T, Fn>(&self, f: Fn) -> impl 'static + Future<Output = T>
726 where
727 T: 'static + Send,
728 Fn: 'static + Send + for<'a> FnOnce(&'a mut AsyncApp) -> LocalBoxFuture<'a, T>,
729 {
730 let (return_tx, return_rx) = oneshot::channel();
731 self.host
732 .main_thread_message_tx
733 .clone()
734 .unbounded_send(Box::new(move |cx| {
735 async {
736 let result = f(cx).await;
737 return_tx.send(result).ok();
738 }
739 .boxed_local()
740 }))
741 .expect("main thread message channel should not be closed yet");
742 async move { return_rx.await.expect("main thread message channel") }
743 }
744
745 fn work_dir(&self) -> PathBuf {
746 self.host.work_dir.join(self.manifest.id.as_ref())
747 }
748
749 fn extension_error(&self, message: String) -> anyhow::Error {
750 anyhow!(
751 "from extension \"{}\" version {}: {}",
752 self.manifest.name,
753 self.manifest.version,
754 message
755 )
756 }
757}
758
759impl wasi::WasiView for WasmState {
760 fn table(&mut self) -> &mut ResourceTable {
761 &mut self.table
762 }
763
764 fn ctx(&mut self) -> &mut wasi::WasiCtx {
765 &mut self.ctx
766 }
767}
768
769/// Wrapper around a mini-moka bounded cache for storing incremental compilation artifacts.
770/// Since wasm modules have many similar elements, this can save us a lot of work at the
771/// cost of a small memory footprint. However, we don't want this to be unbounded, so we use
772/// a LFU/LRU cache to evict less used cache entries.
773#[derive(Debug)]
774struct IncrementalCompilationCache {
775 cache: Cache<Vec<u8>, Vec<u8>>,
776}
777
778impl IncrementalCompilationCache {
779 fn new() -> Self {
780 let cache = Cache::builder()
781 // Cap this at 32 MB for now. Our extensions turn into roughly 512kb in the cache,
782 // which means we could store 64 completely novel extensions in the cache, but in
783 // practice we will more than that, which is more than enough for our use case.
784 .max_capacity(32 * 1024 * 1024)
785 .weigher(|k: &Vec<u8>, v: &Vec<u8>| (k.len() + v.len()).try_into().unwrap_or(u32::MAX))
786 .build();
787 Self { cache }
788 }
789}
790
791impl CacheStore for IncrementalCompilationCache {
792 fn get(&self, key: &[u8]) -> Option<Cow<'_, [u8]>> {
793 self.cache.get(key).map(|v| v.into())
794 }
795
796 fn insert(&self, key: &[u8], value: Vec<u8>) -> bool {
797 self.cache.insert(key.to_vec(), value);
798 true
799 }
800}