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, LanguageName, LanguageRegistry, LocalFile as _, LspAdapter,
12 LspAdapterDelegate, LspInstaller, Toolchain,
13};
14use lsp::{LanguageServerBinary, LanguageServerName};
15use node_runtime::{NodeRuntime, VersionStrategy};
16use project::lsp_store::language_server_settings;
17use serde_json::{Value, json};
18use settings::{KeymapFile, SettingsJsonSchemaParams, SettingsStore};
19use smol::{
20 fs::{self},
21 io::BufReader,
22 lock::RwLock,
23};
24use std::{
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 file: Option<Arc<dyn language::File>>,
49 cx: &App,
50 ) -> gpui::Task<Option<TaskTemplates>> {
51 let Some(file) = project::File::from_dyn(file.as_ref()).cloned() else {
52 return Task::ready(None);
53 };
54 let is_package_json = file.path.ends_with("package.json");
55 let is_composer_json = file.path.ends_with("composer.json");
56 if !is_package_json && !is_composer_json {
57 return Task::ready(None);
58 }
59
60 cx.spawn(async move |cx| {
61 let contents = file
62 .worktree
63 .update(cx, |this, cx| this.load_file(&file.path, cx))
64 .ok()?
65 .await
66 .ok()?;
67 let path = cx.update(|cx| file.abs_path(cx)).ok()?.as_path().into();
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(path, 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 schemas
233 .as_array_mut()
234 .unwrap()
235 .extend(cx.all_action_names().iter().map(|&name| {
236 project::lsp_store::json_language_server_ext::url_schema_for_action(name)
237 }));
238
239 // This can be viewed via `dev: open language server logs` -> `json-language-server` ->
240 // `Server Info`
241 serde_json::json!({
242 "json": {
243 "format": {
244 "enable": true,
245 },
246 "validate":
247 {
248 "enable": true,
249 },
250 "schemas": schemas
251 }
252 })
253 }
254
255 async fn get_or_init_workspace_config(&self, cx: &mut AsyncApp) -> Result<Value> {
256 {
257 let reader = self.workspace_config.read().await;
258 if let Some(config) = reader.as_ref() {
259 return Ok(config.clone());
260 }
261 }
262 let mut writer = self.workspace_config.write().await;
263
264 let adapter_schemas = cx
265 .read_global::<DapRegistry, _>(|dap_registry, _| dap_registry.to_owned())?
266 .adapters_schema()
267 .await;
268
269 let config = cx.update(|cx| {
270 Self::get_workspace_config(
271 self.languages
272 .language_names()
273 .into_iter()
274 .map(|name| name.to_string())
275 .collect(),
276 adapter_schemas,
277 cx,
278 )
279 })?;
280 writer.replace(config.clone());
281 Ok(config)
282 }
283}
284
285#[cfg(debug_assertions)]
286fn generate_inspector_style_schema() -> serde_json_lenient::Value {
287 let schema = schemars::generate::SchemaSettings::draft2019_09()
288 .with_transform(util::schemars::DefaultDenyUnknownFields)
289 .into_generator()
290 .root_schema_for::<gpui::StyleRefinement>();
291
292 serde_json_lenient::to_value(schema).unwrap()
293}
294
295impl LspInstaller for JsonLspAdapter {
296 type BinaryVersion = String;
297
298 async fn fetch_latest_server_version(
299 &self,
300 _: &dyn LspAdapterDelegate,
301 _: bool,
302 _: &mut AsyncApp,
303 ) -> Result<String> {
304 self.node
305 .npm_package_latest_version(Self::PACKAGE_NAME)
306 .await
307 }
308
309 async fn check_if_user_installed(
310 &self,
311 delegate: &dyn LspAdapterDelegate,
312 _: Option<Toolchain>,
313 _: &AsyncApp,
314 ) -> Option<LanguageServerBinary> {
315 let path = delegate
316 .which("vscode-json-language-server".as_ref())
317 .await?;
318 let env = delegate.shell_env().await;
319
320 Some(LanguageServerBinary {
321 path,
322 env: Some(env),
323 arguments: vec!["--stdio".into()],
324 })
325 }
326
327 async fn check_if_version_installed(
328 &self,
329 version: &String,
330 container_dir: &PathBuf,
331 _: &dyn LspAdapterDelegate,
332 ) -> Option<LanguageServerBinary> {
333 let server_path = container_dir.join(SERVER_PATH);
334
335 let should_install_language_server = self
336 .node
337 .should_install_npm_package(
338 Self::PACKAGE_NAME,
339 &server_path,
340 container_dir,
341 VersionStrategy::Latest(version),
342 )
343 .await;
344
345 if should_install_language_server {
346 None
347 } else {
348 Some(LanguageServerBinary {
349 path: self.node.binary_path().await.ok()?,
350 env: None,
351 arguments: server_binary_arguments(&server_path),
352 })
353 }
354 }
355
356 async fn fetch_server_binary(
357 &self,
358 latest_version: String,
359 container_dir: PathBuf,
360 _: &dyn LspAdapterDelegate,
361 ) -> Result<LanguageServerBinary> {
362 let server_path = container_dir.join(SERVER_PATH);
363
364 self.node
365 .npm_install_packages(
366 &container_dir,
367 &[(Self::PACKAGE_NAME, latest_version.as_str())],
368 )
369 .await?;
370
371 Ok(LanguageServerBinary {
372 path: self.node.binary_path().await?,
373 env: None,
374 arguments: server_binary_arguments(&server_path),
375 })
376 }
377
378 async fn cached_server_binary(
379 &self,
380 container_dir: PathBuf,
381 _: &dyn LspAdapterDelegate,
382 ) -> Option<LanguageServerBinary> {
383 get_cached_server_binary(container_dir, &self.node).await
384 }
385}
386
387#[async_trait(?Send)]
388impl LspAdapter for JsonLspAdapter {
389 fn name(&self) -> LanguageServerName {
390 LanguageServerName("json-language-server".into())
391 }
392
393 async fn initialization_options(
394 self: Arc<Self>,
395 _: &Arc<dyn LspAdapterDelegate>,
396 ) -> Result<Option<serde_json::Value>> {
397 Ok(Some(json!({
398 "provideFormatter": true
399 })))
400 }
401
402 async fn workspace_configuration(
403 self: Arc<Self>,
404 delegate: &Arc<dyn LspAdapterDelegate>,
405 _: Option<Toolchain>,
406 cx: &mut AsyncApp,
407 ) -> Result<Value> {
408 let mut config = self.get_or_init_workspace_config(cx).await?;
409
410 let project_options = cx.update(|cx| {
411 language_server_settings(delegate.as_ref(), &self.name(), cx)
412 .and_then(|s| s.settings.clone())
413 })?;
414
415 if let Some(override_options) = project_options {
416 merge_json_value_into(override_options, &mut config);
417 }
418
419 Ok(config)
420 }
421
422 fn language_ids(&self) -> HashMap<LanguageName, String> {
423 [
424 (LanguageName::new("JSON"), "json".into()),
425 (LanguageName::new("JSONC"), "jsonc".into()),
426 ]
427 .into_iter()
428 .collect()
429 }
430
431 fn is_primary_zed_json_schema_adapter(&self) -> bool {
432 true
433 }
434
435 async fn clear_zed_json_schema_cache(&self) {
436 self.workspace_config.write().await.take();
437 }
438}
439
440async fn get_cached_server_binary(
441 container_dir: PathBuf,
442 node: &NodeRuntime,
443) -> Option<LanguageServerBinary> {
444 maybe!(async {
445 let mut last_version_dir = None;
446 let mut entries = fs::read_dir(&container_dir).await?;
447 while let Some(entry) = entries.next().await {
448 let entry = entry?;
449 if entry.file_type().await?.is_dir() {
450 last_version_dir = Some(entry.path());
451 }
452 }
453
454 let last_version_dir = last_version_dir.context("no cached binary")?;
455 let server_path = last_version_dir.join(SERVER_PATH);
456 anyhow::ensure!(
457 server_path.exists(),
458 "missing executable in directory {last_version_dir:?}"
459 );
460 Ok(LanguageServerBinary {
461 path: node.binary_path().await?,
462 env: None,
463 arguments: server_binary_arguments(&server_path),
464 })
465 })
466 .await
467 .log_err()
468}
469
470#[inline]
471fn schema_file_match(path: &Path) -> String {
472 path.strip_prefix(path.parent().unwrap().parent().unwrap())
473 .unwrap()
474 .display()
475 .to_string()
476 .replace('\\', "/")
477}
478
479pub struct NodeVersionAdapter;
480
481impl NodeVersionAdapter {
482 const SERVER_NAME: LanguageServerName =
483 LanguageServerName::new_static("package-version-server");
484}
485
486impl LspInstaller for NodeVersionAdapter {
487 type BinaryVersion = GitHubLspBinaryVersion;
488
489 async fn fetch_latest_server_version(
490 &self,
491 delegate: &dyn LspAdapterDelegate,
492 _: bool,
493 _: &mut AsyncApp,
494 ) -> Result<GitHubLspBinaryVersion> {
495 let release = latest_github_release(
496 "zed-industries/package-version-server",
497 true,
498 false,
499 delegate.http_client(),
500 )
501 .await?;
502 let os = match consts::OS {
503 "macos" => "apple-darwin",
504 "linux" => "unknown-linux-gnu",
505 "windows" => "pc-windows-msvc",
506 other => bail!("Running on unsupported os: {other}"),
507 };
508 let suffix = if consts::OS == "windows" {
509 ".zip"
510 } else {
511 ".tar.gz"
512 };
513 let asset_name = format!("{}-{}-{os}{suffix}", Self::SERVER_NAME, consts::ARCH);
514 let asset = release
515 .assets
516 .iter()
517 .find(|asset| asset.name == asset_name)
518 .with_context(|| format!("no asset found matching `{asset_name:?}`"))?;
519 Ok(GitHubLspBinaryVersion {
520 name: release.tag_name,
521 url: asset.browser_download_url.clone(),
522 digest: asset.digest.clone(),
523 })
524 }
525
526 async fn check_if_user_installed(
527 &self,
528 delegate: &dyn LspAdapterDelegate,
529 _: Option<Toolchain>,
530 _: &AsyncApp,
531 ) -> Option<LanguageServerBinary> {
532 let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
533 Some(LanguageServerBinary {
534 path,
535 env: None,
536 arguments: Default::default(),
537 })
538 }
539
540 async fn fetch_server_binary(
541 &self,
542 latest_version: GitHubLspBinaryVersion,
543 container_dir: PathBuf,
544 delegate: &dyn LspAdapterDelegate,
545 ) -> Result<LanguageServerBinary> {
546 let version = &latest_version;
547 let destination_path = container_dir.join(format!(
548 "{}-{}{}",
549 Self::SERVER_NAME,
550 version.name,
551 std::env::consts::EXE_SUFFIX
552 ));
553 let destination_container_path =
554 container_dir.join(format!("{}-{}-tmp", Self::SERVER_NAME, version.name));
555 if fs::metadata(&destination_path).await.is_err() {
556 let mut response = delegate
557 .http_client()
558 .get(&version.url, Default::default(), true)
559 .await
560 .context("downloading release")?;
561 if version.url.ends_with(".zip") {
562 extract_zip(&destination_container_path, response.body_mut()).await?;
563 } else if version.url.ends_with(".tar.gz") {
564 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
565 let archive = Archive::new(decompressed_bytes);
566 archive.unpack(&destination_container_path).await?;
567 }
568
569 fs::copy(
570 destination_container_path.join(format!(
571 "{}{}",
572 Self::SERVER_NAME,
573 std::env::consts::EXE_SUFFIX
574 )),
575 &destination_path,
576 )
577 .await?;
578 remove_matching(&container_dir, |entry| entry != destination_path).await;
579 }
580 Ok(LanguageServerBinary {
581 path: destination_path,
582 env: None,
583 arguments: Default::default(),
584 })
585 }
586
587 async fn cached_server_binary(
588 &self,
589 container_dir: PathBuf,
590 _delegate: &dyn LspAdapterDelegate,
591 ) -> Option<LanguageServerBinary> {
592 get_cached_version_server_binary(container_dir).await
593 }
594}
595
596#[async_trait(?Send)]
597impl LspAdapter for NodeVersionAdapter {
598 fn name(&self) -> LanguageServerName {
599 Self::SERVER_NAME
600 }
601}
602
603async fn get_cached_version_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
604 maybe!(async {
605 let mut last = None;
606 let mut entries = fs::read_dir(&container_dir).await?;
607 while let Some(entry) = entries.next().await {
608 last = Some(entry?.path());
609 }
610
611 anyhow::Ok(LanguageServerBinary {
612 path: last.context("no cached binary")?,
613 env: None,
614 arguments: Default::default(),
615 })
616 })
617 .await
618 .log_err()
619}