1use anyhow::{Context as _, Result, bail};
2use async_compression::futures::bufread::GzipDecoder;
3use async_tar::Archive;
4use async_trait::async_trait;
5use collections::HashMap;
6use dap::DapRegistry;
7use futures::StreamExt;
8use gpui::{App, AsyncApp, Task};
9use http_client::github::{GitHubLspBinaryVersion, latest_github_release};
10use language::{
11 ContextProvider, LanguageRegistry, LanguageToolchainStore, LspAdapter, LspAdapterDelegate,
12};
13use lsp::{LanguageServerBinary, LanguageServerName};
14use node_runtime::NodeRuntime;
15use project::{Fs, lsp_store::language_server_settings};
16use serde_json::{Value, json};
17use settings::{KeymapFile, SettingsJsonSchemaParams, SettingsStore};
18use smol::{
19 fs::{self},
20 io::BufReader,
21 lock::RwLock,
22};
23use std::{
24 any::Any,
25 env::consts,
26 ffi::OsString,
27 path::{Path, PathBuf},
28 str::FromStr,
29 sync::Arc,
30};
31use task::{AdapterSchemas, TaskTemplate, TaskTemplates, VariableName};
32use util::{ResultExt, archive::extract_zip, fs::remove_matching, maybe, merge_json_value_into};
33
34use crate::PackageJsonData;
35
36const SERVER_PATH: &str =
37 "node_modules/vscode-langservers-extracted/bin/vscode-json-language-server";
38
39// Origin: https://github.com/SchemaStore/schemastore
40const TSCONFIG_SCHEMA: &str = include_str!("json/schemas/tsconfig.json");
41const PACKAGE_JSON_SCHEMA: &str = include_str!("json/schemas/package.json");
42
43pub(crate) struct JsonTaskProvider;
44
45impl ContextProvider for JsonTaskProvider {
46 fn associated_tasks(
47 &self,
48 _: Arc<dyn Fs>,
49 file: Option<Arc<dyn language::File>>,
50 cx: &App,
51 ) -> gpui::Task<Option<TaskTemplates>> {
52 let Some(file) = project::File::from_dyn(file.as_ref()).cloned() else {
53 return Task::ready(None);
54 };
55 let is_package_json = file.path.ends_with("package.json");
56 let is_composer_json = file.path.ends_with("composer.json");
57 if !is_package_json && !is_composer_json {
58 return Task::ready(None);
59 }
60
61 cx.spawn(async move |cx| {
62 let contents = file
63 .worktree
64 .update(cx, |this, cx| this.load_file(&file.path, cx))
65 .ok()?
66 .await
67 .ok()?;
68
69 let task_templates = if is_package_json {
70 let package_json = serde_json_lenient::from_str::<
71 HashMap<String, serde_json_lenient::Value>,
72 >(&contents.text)
73 .ok()?;
74 let package_json = PackageJsonData::new(file.path.clone(), package_json);
75 let command = package_json.package_manager.unwrap_or("npm").to_owned();
76 package_json
77 .scripts
78 .into_iter()
79 .map(|(_, key)| TaskTemplate {
80 label: format!("run {key}"),
81 command: command.clone(),
82 args: vec!["run".into(), key],
83 cwd: Some(VariableName::Dirname.template_value()),
84 ..TaskTemplate::default()
85 })
86 .chain([TaskTemplate {
87 label: "package script $ZED_CUSTOM_script".to_owned(),
88 command: command.clone(),
89 args: vec![
90 "run".into(),
91 VariableName::Custom("script".into()).template_value(),
92 ],
93 cwd: Some(VariableName::Dirname.template_value()),
94 tags: vec!["package-script".into()],
95 ..TaskTemplate::default()
96 }])
97 .collect()
98 } else if is_composer_json {
99 serde_json_lenient::Value::from_str(&contents.text)
100 .ok()?
101 .get("scripts")?
102 .as_object()?
103 .keys()
104 .map(|key| TaskTemplate {
105 label: format!("run {key}"),
106 command: "composer".to_owned(),
107 args: vec!["-d".into(), "$ZED_DIRNAME".into(), key.into()],
108 ..TaskTemplate::default()
109 })
110 .chain([TaskTemplate {
111 label: "composer script $ZED_CUSTOM_script".to_owned(),
112 command: "composer".to_owned(),
113 args: vec![
114 "-d".into(),
115 "$ZED_DIRNAME".into(),
116 VariableName::Custom("script".into()).template_value(),
117 ],
118 tags: vec!["composer-script".into()],
119 ..TaskTemplate::default()
120 }])
121 .collect()
122 } else {
123 vec![]
124 };
125
126 Some(TaskTemplates(task_templates))
127 })
128 }
129}
130
131fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
132 vec![server_path.into(), "--stdio".into()]
133}
134
135pub struct JsonLspAdapter {
136 node: NodeRuntime,
137 languages: Arc<LanguageRegistry>,
138 workspace_config: RwLock<Option<Value>>,
139}
140
141impl JsonLspAdapter {
142 const PACKAGE_NAME: &str = "vscode-langservers-extracted";
143
144 pub fn new(node: NodeRuntime, languages: Arc<LanguageRegistry>) -> Self {
145 Self {
146 node,
147 languages,
148 workspace_config: Default::default(),
149 }
150 }
151
152 fn get_workspace_config(
153 language_names: Vec<String>,
154 adapter_schemas: AdapterSchemas,
155 cx: &mut App,
156 ) -> Value {
157 let keymap_schema = KeymapFile::generate_json_schema_for_registered_actions(cx);
158 let font_names = &cx.text_system().all_font_names();
159 let settings_schema = cx.global::<SettingsStore>().json_schema(
160 &SettingsJsonSchemaParams {
161 language_names: &language_names,
162 font_names,
163 },
164 cx,
165 );
166
167 let tasks_schema = task::TaskTemplates::generate_json_schema();
168 let debug_schema = task::DebugTaskFile::generate_json_schema(&adapter_schemas);
169 let snippets_schema = snippet_provider::format::VsSnippetsFile::generate_json_schema();
170 let tsconfig_schema = serde_json::Value::from_str(TSCONFIG_SCHEMA).unwrap();
171 let package_json_schema = serde_json::Value::from_str(PACKAGE_JSON_SCHEMA).unwrap();
172
173 #[allow(unused_mut)]
174 let mut schemas = serde_json::json!([
175 {
176 "fileMatch": ["tsconfig.json"],
177 "schema":tsconfig_schema
178 },
179 {
180 "fileMatch": ["package.json"],
181 "schema":package_json_schema
182 },
183 {
184 "fileMatch": [
185 schema_file_match(paths::settings_file()),
186 paths::local_settings_file_relative_path()
187 ],
188 "schema": settings_schema,
189 },
190 {
191 "fileMatch": [schema_file_match(paths::keymap_file())],
192 "schema": keymap_schema,
193 },
194 {
195 "fileMatch": [
196 schema_file_match(paths::tasks_file()),
197 paths::local_tasks_file_relative_path()
198 ],
199 "schema": tasks_schema,
200 },
201 {
202 "fileMatch": [
203 schema_file_match(
204 paths::snippets_dir()
205 .join("*.json")
206 .as_path()
207 )
208 ],
209 "schema": snippets_schema,
210 },
211 {
212 "fileMatch": [
213 schema_file_match(paths::debug_scenarios_file()),
214 paths::local_debug_file_relative_path()
215 ],
216 "schema": debug_schema,
217 },
218 ]);
219
220 #[cfg(debug_assertions)]
221 {
222 schemas.as_array_mut().unwrap().push(serde_json::json!(
223 {
224 "fileMatch": [
225 "zed-inspector-style.json"
226 ],
227 "schema": generate_inspector_style_schema(),
228 }
229 ))
230 }
231
232 // This can be viewed via `dev: open language server logs` -> `json-language-server` ->
233 // `Server Info`
234 serde_json::json!({
235 "json": {
236 "format": {
237 "enable": true,
238 },
239 "validate":
240 {
241 "enable": true,
242 },
243 "schemas": schemas
244 }
245 })
246 }
247
248 async fn get_or_init_workspace_config(&self, cx: &mut AsyncApp) -> Result<Value> {
249 {
250 let reader = self.workspace_config.read().await;
251 if let Some(config) = reader.as_ref() {
252 return Ok(config.clone());
253 }
254 }
255 let mut writer = self.workspace_config.write().await;
256
257 let adapter_schemas = cx
258 .read_global::<DapRegistry, _>(|dap_registry, _| dap_registry.to_owned())?
259 .adapters_schema()
260 .await;
261
262 let config = cx.update(|cx| {
263 Self::get_workspace_config(self.languages.language_names().clone(), adapter_schemas, cx)
264 })?;
265 writer.replace(config.clone());
266 return Ok(config);
267 }
268}
269
270#[cfg(debug_assertions)]
271fn generate_inspector_style_schema() -> serde_json_lenient::Value {
272 let schema = schemars::r#gen::SchemaSettings::draft07()
273 .with(|settings| settings.option_add_null_type = false)
274 .into_generator()
275 .into_root_schema_for::<gpui::StyleRefinement>();
276
277 serde_json_lenient::to_value(schema).unwrap()
278}
279
280#[async_trait(?Send)]
281impl LspAdapter for JsonLspAdapter {
282 fn name(&self) -> LanguageServerName {
283 LanguageServerName("json-language-server".into())
284 }
285
286 async fn check_if_user_installed(
287 &self,
288 delegate: &dyn LspAdapterDelegate,
289 _: Arc<dyn LanguageToolchainStore>,
290 _: &AsyncApp,
291 ) -> Option<LanguageServerBinary> {
292 let path = delegate
293 .which("vscode-json-language-server".as_ref())
294 .await?;
295 let env = delegate.shell_env().await;
296
297 Some(LanguageServerBinary {
298 path,
299 env: Some(env),
300 arguments: vec!["--stdio".into()],
301 })
302 }
303
304 async fn fetch_latest_server_version(
305 &self,
306 _: &dyn LspAdapterDelegate,
307 ) -> Result<Box<dyn 'static + Send + Any>> {
308 Ok(Box::new(
309 self.node
310 .npm_package_latest_version(Self::PACKAGE_NAME)
311 .await?,
312 ) as Box<_>)
313 }
314
315 async fn check_if_version_installed(
316 &self,
317 version: &(dyn 'static + Send + Any),
318 container_dir: &PathBuf,
319 _: &dyn LspAdapterDelegate,
320 ) -> Option<LanguageServerBinary> {
321 let version = version.downcast_ref::<String>().unwrap();
322 let server_path = container_dir.join(SERVER_PATH);
323
324 let should_install_language_server = self
325 .node
326 .should_install_npm_package(Self::PACKAGE_NAME, &server_path, &container_dir, &version)
327 .await;
328
329 if should_install_language_server {
330 None
331 } else {
332 Some(LanguageServerBinary {
333 path: self.node.binary_path().await.ok()?,
334 env: None,
335 arguments: server_binary_arguments(&server_path),
336 })
337 }
338 }
339
340 async fn fetch_server_binary(
341 &self,
342 latest_version: Box<dyn 'static + Send + Any>,
343 container_dir: PathBuf,
344 _: &dyn LspAdapterDelegate,
345 ) -> Result<LanguageServerBinary> {
346 let latest_version = latest_version.downcast::<String>().unwrap();
347 let server_path = container_dir.join(SERVER_PATH);
348
349 self.node
350 .npm_install_packages(
351 &container_dir,
352 &[(Self::PACKAGE_NAME, latest_version.as_str())],
353 )
354 .await?;
355
356 Ok(LanguageServerBinary {
357 path: self.node.binary_path().await?,
358 env: None,
359 arguments: server_binary_arguments(&server_path),
360 })
361 }
362
363 async fn cached_server_binary(
364 &self,
365 container_dir: PathBuf,
366 _: &dyn LspAdapterDelegate,
367 ) -> Option<LanguageServerBinary> {
368 get_cached_server_binary(container_dir, &self.node).await
369 }
370
371 async fn initialization_options(
372 self: Arc<Self>,
373 _: &dyn Fs,
374 _: &Arc<dyn LspAdapterDelegate>,
375 ) -> Result<Option<serde_json::Value>> {
376 Ok(Some(json!({
377 "provideFormatter": true
378 })))
379 }
380
381 async fn workspace_configuration(
382 self: Arc<Self>,
383 _: &dyn Fs,
384 delegate: &Arc<dyn LspAdapterDelegate>,
385 _: Arc<dyn LanguageToolchainStore>,
386 cx: &mut AsyncApp,
387 ) -> Result<Value> {
388 let mut config = self.get_or_init_workspace_config(cx).await?;
389
390 let project_options = cx.update(|cx| {
391 language_server_settings(delegate.as_ref(), &self.name(), cx)
392 .and_then(|s| s.settings.clone())
393 })?;
394
395 if let Some(override_options) = project_options {
396 merge_json_value_into(override_options, &mut config);
397 }
398
399 Ok(config)
400 }
401
402 fn language_ids(&self) -> HashMap<String, String> {
403 [
404 ("JSON".into(), "json".into()),
405 ("JSONC".into(), "jsonc".into()),
406 ]
407 .into_iter()
408 .collect()
409 }
410
411 fn is_primary_zed_json_schema_adapter(&self) -> bool {
412 true
413 }
414
415 async fn clear_zed_json_schema_cache(&self) {
416 self.workspace_config.write().await.take();
417 }
418}
419
420async fn get_cached_server_binary(
421 container_dir: PathBuf,
422 node: &NodeRuntime,
423) -> Option<LanguageServerBinary> {
424 maybe!(async {
425 let mut last_version_dir = None;
426 let mut entries = fs::read_dir(&container_dir).await?;
427 while let Some(entry) = entries.next().await {
428 let entry = entry?;
429 if entry.file_type().await?.is_dir() {
430 last_version_dir = Some(entry.path());
431 }
432 }
433
434 let last_version_dir = last_version_dir.context("no cached binary")?;
435 let server_path = last_version_dir.join(SERVER_PATH);
436 anyhow::ensure!(
437 server_path.exists(),
438 "missing executable in directory {last_version_dir:?}"
439 );
440 Ok(LanguageServerBinary {
441 path: node.binary_path().await?,
442 env: None,
443 arguments: server_binary_arguments(&server_path),
444 })
445 })
446 .await
447 .log_err()
448}
449
450#[inline]
451fn schema_file_match(path: &Path) -> String {
452 path.strip_prefix(path.parent().unwrap().parent().unwrap())
453 .unwrap()
454 .display()
455 .to_string()
456 .replace('\\', "/")
457}
458
459pub struct NodeVersionAdapter;
460
461impl NodeVersionAdapter {
462 const SERVER_NAME: LanguageServerName =
463 LanguageServerName::new_static("package-version-server");
464}
465
466#[async_trait(?Send)]
467impl LspAdapter for NodeVersionAdapter {
468 fn name(&self) -> LanguageServerName {
469 Self::SERVER_NAME.clone()
470 }
471
472 async fn fetch_latest_server_version(
473 &self,
474 delegate: &dyn LspAdapterDelegate,
475 ) -> Result<Box<dyn 'static + Send + Any>> {
476 let release = latest_github_release(
477 "zed-industries/package-version-server",
478 true,
479 false,
480 delegate.http_client(),
481 )
482 .await?;
483 let os = match consts::OS {
484 "macos" => "apple-darwin",
485 "linux" => "unknown-linux-gnu",
486 "windows" => "pc-windows-msvc",
487 other => bail!("Running on unsupported os: {other}"),
488 };
489 let suffix = if consts::OS == "windows" {
490 ".zip"
491 } else {
492 ".tar.gz"
493 };
494 let asset_name = format!("{}-{}-{os}{suffix}", Self::SERVER_NAME, consts::ARCH);
495 let asset = release
496 .assets
497 .iter()
498 .find(|asset| asset.name == asset_name)
499 .with_context(|| format!("no asset found matching `{asset_name:?}`"))?;
500 Ok(Box::new(GitHubLspBinaryVersion {
501 name: release.tag_name,
502 url: asset.browser_download_url.clone(),
503 }))
504 }
505
506 async fn check_if_user_installed(
507 &self,
508 delegate: &dyn LspAdapterDelegate,
509 _: Arc<dyn LanguageToolchainStore>,
510 _: &AsyncApp,
511 ) -> Option<LanguageServerBinary> {
512 let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
513 Some(LanguageServerBinary {
514 path,
515 env: None,
516 arguments: Default::default(),
517 })
518 }
519
520 async fn fetch_server_binary(
521 &self,
522 latest_version: Box<dyn 'static + Send + Any>,
523 container_dir: PathBuf,
524 delegate: &dyn LspAdapterDelegate,
525 ) -> Result<LanguageServerBinary> {
526 let version = latest_version.downcast::<GitHubLspBinaryVersion>().unwrap();
527 let destination_path = container_dir.join(format!(
528 "{}-{}{}",
529 Self::SERVER_NAME,
530 version.name,
531 std::env::consts::EXE_SUFFIX
532 ));
533 let destination_container_path =
534 container_dir.join(format!("{}-{}-tmp", Self::SERVER_NAME, version.name));
535 if fs::metadata(&destination_path).await.is_err() {
536 let mut response = delegate
537 .http_client()
538 .get(&version.url, Default::default(), true)
539 .await
540 .context("downloading release")?;
541 if version.url.ends_with(".zip") {
542 extract_zip(&destination_container_path, response.body_mut()).await?;
543 } else if version.url.ends_with(".tar.gz") {
544 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
545 let archive = Archive::new(decompressed_bytes);
546 archive.unpack(&destination_container_path).await?;
547 }
548
549 fs::copy(
550 destination_container_path.join(format!(
551 "{}{}",
552 Self::SERVER_NAME,
553 std::env::consts::EXE_SUFFIX
554 )),
555 &destination_path,
556 )
557 .await?;
558 remove_matching(&container_dir, |entry| entry != destination_path).await;
559 }
560 Ok(LanguageServerBinary {
561 path: destination_path,
562 env: None,
563 arguments: Default::default(),
564 })
565 }
566
567 async fn cached_server_binary(
568 &self,
569 container_dir: PathBuf,
570 _delegate: &dyn LspAdapterDelegate,
571 ) -> Option<LanguageServerBinary> {
572 get_cached_version_server_binary(container_dir).await
573 }
574}
575
576async fn get_cached_version_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
577 maybe!(async {
578 let mut last = None;
579 let mut entries = fs::read_dir(&container_dir).await?;
580 while let Some(entry) = entries.next().await {
581 last = Some(entry?.path());
582 }
583
584 anyhow::Ok(LanguageServerBinary {
585 path: last.context("no cached binary")?,
586 env: None,
587 arguments: Default::default(),
588 })
589 })
590 .await
591 .log_err()
592}