1pub mod wit;
2
3use crate::ExtensionManifest;
4use anyhow::{anyhow, bail, Context as _, Result};
5use async_trait::async_trait;
6use extension::{
7 CodeLabel, Command, Completion, ExtensionHostProxy, KeyValueStoreDelegate, ProjectDelegate,
8 SlashCommand, SlashCommandArgumentCompletion, SlashCommandOutput, Symbol, WorktreeDelegate,
9};
10use fs::{normalize_path, Fs};
11use futures::future::LocalBoxFuture;
12use futures::{
13 channel::{
14 mpsc::{self, UnboundedSender},
15 oneshot,
16 },
17 future::BoxFuture,
18 Future, FutureExt, StreamExt as _,
19};
20use gpui::{AppContext, AsyncAppContext, BackgroundExecutor, Task};
21use http_client::HttpClient;
22use language::LanguageName;
23use lsp::LanguageServerName;
24use node_runtime::NodeRuntime;
25use release_channel::ReleaseChannel;
26use semantic_version::SemanticVersion;
27use std::{
28 path::{Path, PathBuf},
29 sync::{Arc, OnceLock},
30};
31use wasmtime::{
32 component::{Component, ResourceTable},
33 Engine, Store,
34};
35use wasmtime_wasi::{self as wasi, WasiView};
36use wit::Extension;
37
38pub struct WasmHost {
39 engine: Engine,
40 release_channel: ReleaseChannel,
41 http_client: Arc<dyn HttpClient>,
42 node_runtime: NodeRuntime,
43 pub(crate) proxy: Arc<ExtensionHostProxy>,
44 fs: Arc<dyn Fs>,
45 pub work_dir: PathBuf,
46 _main_thread_message_task: Task<()>,
47 main_thread_message_tx: mpsc::UnboundedSender<MainThreadCall>,
48}
49
50#[derive(Clone)]
51pub struct WasmExtension {
52 tx: UnboundedSender<ExtensionCall>,
53 pub manifest: Arc<ExtensionManifest>,
54 pub work_dir: Arc<Path>,
55 #[allow(unused)]
56 pub zed_api_version: SemanticVersion,
57}
58
59#[async_trait]
60impl extension::Extension for WasmExtension {
61 fn manifest(&self) -> Arc<ExtensionManifest> {
62 self.manifest.clone()
63 }
64
65 fn work_dir(&self) -> Arc<Path> {
66 self.work_dir.clone()
67 }
68
69 async fn language_server_command(
70 &self,
71 language_server_id: LanguageServerName,
72 language_name: LanguageName,
73 worktree: Arc<dyn WorktreeDelegate>,
74 ) -> Result<Command> {
75 self.call(|extension, store| {
76 async move {
77 let resource = store.data_mut().table().push(worktree)?;
78 let command = extension
79 .call_language_server_command(
80 store,
81 &language_server_id,
82 &language_name,
83 resource,
84 )
85 .await?
86 .map_err(|err| anyhow!("{err}"))?;
87
88 Ok(command.into())
89 }
90 .boxed()
91 })
92 .await
93 }
94
95 async fn language_server_initialization_options(
96 &self,
97 language_server_id: LanguageServerName,
98 language_name: LanguageName,
99 worktree: Arc<dyn WorktreeDelegate>,
100 ) -> Result<Option<String>> {
101 self.call(|extension, store| {
102 async move {
103 let resource = store.data_mut().table().push(worktree)?;
104 let options = extension
105 .call_language_server_initialization_options(
106 store,
107 &language_server_id,
108 &language_name,
109 resource,
110 )
111 .await?
112 .map_err(|err| anyhow!("{err}"))?;
113 anyhow::Ok(options)
114 }
115 .boxed()
116 })
117 .await
118 }
119
120 async fn language_server_workspace_configuration(
121 &self,
122 language_server_id: LanguageServerName,
123 worktree: Arc<dyn WorktreeDelegate>,
124 ) -> Result<Option<String>> {
125 self.call(|extension, store| {
126 async move {
127 let resource = store.data_mut().table().push(worktree)?;
128 let options = extension
129 .call_language_server_workspace_configuration(
130 store,
131 &language_server_id,
132 resource,
133 )
134 .await?
135 .map_err(|err| anyhow!("{err}"))?;
136 anyhow::Ok(options)
137 }
138 .boxed()
139 })
140 .await
141 }
142
143 async fn labels_for_completions(
144 &self,
145 language_server_id: LanguageServerName,
146 completions: Vec<Completion>,
147 ) -> Result<Vec<Option<CodeLabel>>> {
148 self.call(|extension, store| {
149 async move {
150 let labels = extension
151 .call_labels_for_completions(
152 store,
153 &language_server_id,
154 completions.into_iter().map(Into::into).collect(),
155 )
156 .await?
157 .map_err(|err| anyhow!("{err}"))?;
158
159 Ok(labels
160 .into_iter()
161 .map(|label| label.map(Into::into))
162 .collect())
163 }
164 .boxed()
165 })
166 .await
167 }
168
169 async fn labels_for_symbols(
170 &self,
171 language_server_id: LanguageServerName,
172 symbols: Vec<Symbol>,
173 ) -> Result<Vec<Option<CodeLabel>>> {
174 self.call(|extension, store| {
175 async move {
176 let labels = extension
177 .call_labels_for_symbols(
178 store,
179 &language_server_id,
180 symbols.into_iter().map(Into::into).collect(),
181 )
182 .await?
183 .map_err(|err| anyhow!("{err}"))?;
184
185 Ok(labels
186 .into_iter()
187 .map(|label| label.map(Into::into))
188 .collect())
189 }
190 .boxed()
191 })
192 .await
193 }
194
195 async fn complete_slash_command_argument(
196 &self,
197 command: SlashCommand,
198 arguments: Vec<String>,
199 ) -> Result<Vec<SlashCommandArgumentCompletion>> {
200 self.call(|extension, store| {
201 async move {
202 let completions = extension
203 .call_complete_slash_command_argument(store, &command.into(), &arguments)
204 .await?
205 .map_err(|err| anyhow!("{err}"))?;
206
207 Ok(completions.into_iter().map(Into::into).collect())
208 }
209 .boxed()
210 })
211 .await
212 }
213
214 async fn run_slash_command(
215 &self,
216 command: SlashCommand,
217 arguments: Vec<String>,
218 delegate: Option<Arc<dyn WorktreeDelegate>>,
219 ) -> Result<SlashCommandOutput> {
220 self.call(|extension, store| {
221 async move {
222 let resource = if let Some(delegate) = delegate {
223 Some(store.data_mut().table().push(delegate)?)
224 } else {
225 None
226 };
227
228 let output = extension
229 .call_run_slash_command(store, &command.into(), &arguments, resource)
230 .await?
231 .map_err(|err| anyhow!("{err}"))?;
232
233 Ok(output.into())
234 }
235 .boxed()
236 })
237 .await
238 }
239
240 async fn context_server_command(
241 &self,
242 context_server_id: Arc<str>,
243 project: Arc<dyn ProjectDelegate>,
244 ) -> Result<Command> {
245 self.call(|extension, store| {
246 async move {
247 let project_resource = store.data_mut().table().push(project)?;
248 let command = extension
249 .call_context_server_command(store, context_server_id.clone(), project_resource)
250 .await?
251 .map_err(|err| anyhow!("{err}"))?;
252 anyhow::Ok(command.into())
253 }
254 .boxed()
255 })
256 .await
257 }
258
259 async fn suggest_docs_packages(&self, provider: Arc<str>) -> Result<Vec<String>> {
260 self.call(|extension, store| {
261 async move {
262 let packages = extension
263 .call_suggest_docs_packages(store, provider.as_ref())
264 .await?
265 .map_err(|err| anyhow!("{err:?}"))?;
266
267 Ok(packages)
268 }
269 .boxed()
270 })
271 .await
272 }
273
274 async fn index_docs(
275 &self,
276 provider: Arc<str>,
277 package_name: Arc<str>,
278 kv_store: Arc<dyn KeyValueStoreDelegate>,
279 ) -> Result<()> {
280 self.call(|extension, store| {
281 async move {
282 let kv_store_resource = store.data_mut().table().push(kv_store)?;
283 extension
284 .call_index_docs(
285 store,
286 provider.as_ref(),
287 package_name.as_ref(),
288 kv_store_resource,
289 )
290 .await?
291 .map_err(|err| anyhow!("{err:?}"))?;
292
293 anyhow::Ok(())
294 }
295 .boxed()
296 })
297 .await
298 }
299}
300
301pub struct WasmState {
302 manifest: Arc<ExtensionManifest>,
303 pub table: ResourceTable,
304 ctx: wasi::WasiCtx,
305 pub host: Arc<WasmHost>,
306}
307
308type MainThreadCall =
309 Box<dyn Send + for<'a> FnOnce(&'a mut AsyncAppContext) -> LocalBoxFuture<'a, ()>>;
310
311type ExtensionCall = Box<
312 dyn Send + for<'a> FnOnce(&'a mut Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, ()>,
313>;
314
315fn wasm_engine() -> wasmtime::Engine {
316 static WASM_ENGINE: OnceLock<wasmtime::Engine> = OnceLock::new();
317
318 WASM_ENGINE
319 .get_or_init(|| {
320 let mut config = wasmtime::Config::new();
321 config.wasm_component_model(true);
322 config.async_support(true);
323 wasmtime::Engine::new(&config).unwrap()
324 })
325 .clone()
326}
327
328impl WasmHost {
329 pub fn new(
330 fs: Arc<dyn Fs>,
331 http_client: Arc<dyn HttpClient>,
332 node_runtime: NodeRuntime,
333 proxy: Arc<ExtensionHostProxy>,
334 work_dir: PathBuf,
335 cx: &mut AppContext,
336 ) -> Arc<Self> {
337 let (tx, mut rx) = mpsc::unbounded::<MainThreadCall>();
338 let task = cx.spawn(|mut cx| async move {
339 while let Some(message) = rx.next().await {
340 message(&mut cx).await;
341 }
342 });
343 Arc::new(Self {
344 engine: wasm_engine(),
345 fs,
346 work_dir,
347 http_client,
348 node_runtime,
349 proxy,
350 release_channel: ReleaseChannel::global(cx),
351 _main_thread_message_task: task,
352 main_thread_message_tx: tx,
353 })
354 }
355
356 pub fn load_extension(
357 self: &Arc<Self>,
358 wasm_bytes: Vec<u8>,
359 manifest: &Arc<ExtensionManifest>,
360 executor: BackgroundExecutor,
361 ) -> Task<Result<WasmExtension>> {
362 let this = self.clone();
363 let manifest = manifest.clone();
364 executor.clone().spawn(async move {
365 let zed_api_version = parse_wasm_extension_version(&manifest.id, &wasm_bytes)?;
366
367 let component = Component::from_binary(&this.engine, &wasm_bytes)
368 .context("failed to compile wasm component")?;
369
370 let mut store = wasmtime::Store::new(
371 &this.engine,
372 WasmState {
373 ctx: this.build_wasi_ctx(&manifest).await?,
374 manifest: manifest.clone(),
375 table: ResourceTable::new(),
376 host: this.clone(),
377 },
378 );
379
380 let mut extension = Extension::instantiate_async(
381 &mut store,
382 this.release_channel,
383 zed_api_version,
384 &component,
385 )
386 .await?;
387
388 extension
389 .call_init_extension(&mut store)
390 .await
391 .context("failed to initialize wasm extension")?;
392
393 let (tx, mut rx) = mpsc::unbounded::<ExtensionCall>();
394 executor
395 .spawn(async move {
396 while let Some(call) = rx.next().await {
397 (call)(&mut extension, &mut store).await;
398 }
399 })
400 .detach();
401
402 Ok(WasmExtension {
403 manifest: manifest.clone(),
404 work_dir: this.work_dir.join(manifest.id.as_ref()).into(),
405 tx,
406 zed_api_version,
407 })
408 })
409 }
410
411 async fn build_wasi_ctx(&self, manifest: &Arc<ExtensionManifest>) -> Result<wasi::WasiCtx> {
412 let extension_work_dir = self.work_dir.join(manifest.id.as_ref());
413 self.fs
414 .create_dir(&extension_work_dir)
415 .await
416 .context("failed to create extension work dir")?;
417
418 let file_perms = wasi::FilePerms::all();
419 let dir_perms = wasi::DirPerms::all();
420
421 Ok(wasi::WasiCtxBuilder::new()
422 .inherit_stdio()
423 .preopened_dir(&extension_work_dir, ".", dir_perms, file_perms)?
424 .preopened_dir(
425 &extension_work_dir,
426 extension_work_dir.to_string_lossy(),
427 dir_perms,
428 file_perms,
429 )?
430 .env("PWD", extension_work_dir.to_string_lossy())
431 .env("RUST_BACKTRACE", "full")
432 .build())
433 }
434
435 pub fn writeable_path_from_extension(&self, id: &Arc<str>, path: &Path) -> Result<PathBuf> {
436 let extension_work_dir = self.work_dir.join(id.as_ref());
437 let path = normalize_path(&extension_work_dir.join(path));
438 if path.starts_with(&extension_work_dir) {
439 Ok(path)
440 } else {
441 Err(anyhow!("cannot write to path {}", path.display()))
442 }
443 }
444}
445
446pub fn parse_wasm_extension_version(
447 extension_id: &str,
448 wasm_bytes: &[u8],
449) -> Result<SemanticVersion> {
450 let mut version = None;
451
452 for part in wasmparser::Parser::new(0).parse_all(wasm_bytes) {
453 if let wasmparser::Payload::CustomSection(s) =
454 part.context("error parsing wasm extension")?
455 {
456 if s.name() == "zed:api-version" {
457 version = parse_wasm_extension_version_custom_section(s.data());
458 if version.is_none() {
459 bail!(
460 "extension {} has invalid zed:api-version section: {:?}",
461 extension_id,
462 s.data()
463 );
464 }
465 }
466 }
467 }
468
469 // The reason we wait until we're done parsing all of the Wasm bytes to return the version
470 // is to work around a panic that can happen inside of Wasmtime when the bytes are invalid.
471 //
472 // By parsing the entirety of the Wasm bytes before we return, we're able to detect this problem
473 // earlier as an `Err` rather than as a panic.
474 version.ok_or_else(|| anyhow!("extension {} has no zed:api-version section", extension_id))
475}
476
477fn parse_wasm_extension_version_custom_section(data: &[u8]) -> Option<SemanticVersion> {
478 if data.len() == 6 {
479 Some(SemanticVersion::new(
480 u16::from_be_bytes([data[0], data[1]]) as _,
481 u16::from_be_bytes([data[2], data[3]]) as _,
482 u16::from_be_bytes([data[4], data[5]]) as _,
483 ))
484 } else {
485 None
486 }
487}
488
489impl WasmExtension {
490 pub async fn load(
491 extension_dir: PathBuf,
492 manifest: &Arc<ExtensionManifest>,
493 wasm_host: Arc<WasmHost>,
494 cx: &AsyncAppContext,
495 ) -> Result<Self> {
496 let path = extension_dir.join("extension.wasm");
497
498 let mut wasm_file = wasm_host
499 .fs
500 .open_sync(&path)
501 .await
502 .context("failed to open wasm file")?;
503
504 let mut wasm_bytes = Vec::new();
505 wasm_file
506 .read_to_end(&mut wasm_bytes)
507 .context("failed to read wasm")?;
508
509 wasm_host
510 .load_extension(wasm_bytes, manifest, cx.background_executor().clone())
511 .await
512 .with_context(|| format!("failed to load wasm extension {}", manifest.id))
513 }
514
515 pub async fn call<T, Fn>(&self, f: Fn) -> T
516 where
517 T: 'static + Send,
518 Fn: 'static
519 + Send
520 + for<'a> FnOnce(&'a mut Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, T>,
521 {
522 let (return_tx, return_rx) = oneshot::channel();
523 self.tx
524 .clone()
525 .unbounded_send(Box::new(move |extension, store| {
526 async {
527 let result = f(extension, store).await;
528 return_tx.send(result).ok();
529 }
530 .boxed()
531 }))
532 .expect("wasm extension channel should not be closed yet");
533 return_rx.await.expect("wasm extension channel")
534 }
535}
536
537impl WasmState {
538 fn on_main_thread<T, Fn>(&self, f: Fn) -> impl 'static + Future<Output = T>
539 where
540 T: 'static + Send,
541 Fn: 'static + Send + for<'a> FnOnce(&'a mut AsyncAppContext) -> LocalBoxFuture<'a, T>,
542 {
543 let (return_tx, return_rx) = oneshot::channel();
544 self.host
545 .main_thread_message_tx
546 .clone()
547 .unbounded_send(Box::new(move |cx| {
548 async {
549 let result = f(cx).await;
550 return_tx.send(result).ok();
551 }
552 .boxed_local()
553 }))
554 .expect("main thread message channel should not be closed yet");
555 async move { return_rx.await.expect("main thread message channel") }
556 }
557
558 fn work_dir(&self) -> PathBuf {
559 self.host.work_dir.join(self.manifest.id.as_ref())
560 }
561}
562
563impl wasi::WasiView for WasmState {
564 fn table(&mut self) -> &mut ResourceTable {
565 &mut self.table
566 }
567
568 fn ctx(&mut self) -> &mut wasi::WasiCtx {
569 &mut self.ctx
570 }
571}