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::generate::SchemaSettings::draft2019_09()
273 .into_generator()
274 .root_schema_for::<gpui::StyleRefinement>();
275
276 serde_json_lenient::to_value(schema).unwrap()
277}
278
279#[async_trait(?Send)]
280impl LspAdapter for JsonLspAdapter {
281 fn name(&self) -> LanguageServerName {
282 LanguageServerName("json-language-server".into())
283 }
284
285 async fn check_if_user_installed(
286 &self,
287 delegate: &dyn LspAdapterDelegate,
288 _: Arc<dyn LanguageToolchainStore>,
289 _: &AsyncApp,
290 ) -> Option<LanguageServerBinary> {
291 let path = delegate
292 .which("vscode-json-language-server".as_ref())
293 .await?;
294 let env = delegate.shell_env().await;
295
296 Some(LanguageServerBinary {
297 path,
298 env: Some(env),
299 arguments: vec!["--stdio".into()],
300 })
301 }
302
303 async fn fetch_latest_server_version(
304 &self,
305 _: &dyn LspAdapterDelegate,
306 ) -> Result<Box<dyn 'static + Send + Any>> {
307 Ok(Box::new(
308 self.node
309 .npm_package_latest_version(Self::PACKAGE_NAME)
310 .await?,
311 ) as Box<_>)
312 }
313
314 async fn check_if_version_installed(
315 &self,
316 version: &(dyn 'static + Send + Any),
317 container_dir: &PathBuf,
318 _: &dyn LspAdapterDelegate,
319 ) -> Option<LanguageServerBinary> {
320 let version = version.downcast_ref::<String>().unwrap();
321 let server_path = container_dir.join(SERVER_PATH);
322
323 let should_install_language_server = self
324 .node
325 .should_install_npm_package(Self::PACKAGE_NAME, &server_path, &container_dir, &version)
326 .await;
327
328 if should_install_language_server {
329 None
330 } else {
331 Some(LanguageServerBinary {
332 path: self.node.binary_path().await.ok()?,
333 env: None,
334 arguments: server_binary_arguments(&server_path),
335 })
336 }
337 }
338
339 async fn fetch_server_binary(
340 &self,
341 latest_version: Box<dyn 'static + Send + Any>,
342 container_dir: PathBuf,
343 _: &dyn LspAdapterDelegate,
344 ) -> Result<LanguageServerBinary> {
345 let latest_version = latest_version.downcast::<String>().unwrap();
346 let server_path = container_dir.join(SERVER_PATH);
347
348 self.node
349 .npm_install_packages(
350 &container_dir,
351 &[(Self::PACKAGE_NAME, latest_version.as_str())],
352 )
353 .await?;
354
355 Ok(LanguageServerBinary {
356 path: self.node.binary_path().await?,
357 env: None,
358 arguments: server_binary_arguments(&server_path),
359 })
360 }
361
362 async fn cached_server_binary(
363 &self,
364 container_dir: PathBuf,
365 _: &dyn LspAdapterDelegate,
366 ) -> Option<LanguageServerBinary> {
367 get_cached_server_binary(container_dir, &self.node).await
368 }
369
370 async fn initialization_options(
371 self: Arc<Self>,
372 _: &dyn Fs,
373 _: &Arc<dyn LspAdapterDelegate>,
374 ) -> Result<Option<serde_json::Value>> {
375 Ok(Some(json!({
376 "provideFormatter": true
377 })))
378 }
379
380 async fn workspace_configuration(
381 self: Arc<Self>,
382 _: &dyn Fs,
383 delegate: &Arc<dyn LspAdapterDelegate>,
384 _: Arc<dyn LanguageToolchainStore>,
385 cx: &mut AsyncApp,
386 ) -> Result<Value> {
387 let mut config = self.get_or_init_workspace_config(cx).await?;
388
389 let project_options = cx.update(|cx| {
390 language_server_settings(delegate.as_ref(), &self.name(), cx)
391 .and_then(|s| s.settings.clone())
392 })?;
393
394 if let Some(override_options) = project_options {
395 merge_json_value_into(override_options, &mut config);
396 }
397
398 Ok(config)
399 }
400
401 fn language_ids(&self) -> HashMap<String, String> {
402 [
403 ("JSON".into(), "json".into()),
404 ("JSONC".into(), "jsonc".into()),
405 ]
406 .into_iter()
407 .collect()
408 }
409
410 fn is_primary_zed_json_schema_adapter(&self) -> bool {
411 true
412 }
413
414 async fn clear_zed_json_schema_cache(&self) {
415 self.workspace_config.write().await.take();
416 }
417}
418
419async fn get_cached_server_binary(
420 container_dir: PathBuf,
421 node: &NodeRuntime,
422) -> Option<LanguageServerBinary> {
423 maybe!(async {
424 let mut last_version_dir = None;
425 let mut entries = fs::read_dir(&container_dir).await?;
426 while let Some(entry) = entries.next().await {
427 let entry = entry?;
428 if entry.file_type().await?.is_dir() {
429 last_version_dir = Some(entry.path());
430 }
431 }
432
433 let last_version_dir = last_version_dir.context("no cached binary")?;
434 let server_path = last_version_dir.join(SERVER_PATH);
435 anyhow::ensure!(
436 server_path.exists(),
437 "missing executable in directory {last_version_dir:?}"
438 );
439 Ok(LanguageServerBinary {
440 path: node.binary_path().await?,
441 env: None,
442 arguments: server_binary_arguments(&server_path),
443 })
444 })
445 .await
446 .log_err()
447}
448
449#[inline]
450fn schema_file_match(path: &Path) -> String {
451 path.strip_prefix(path.parent().unwrap().parent().unwrap())
452 .unwrap()
453 .display()
454 .to_string()
455 .replace('\\', "/")
456}
457
458pub struct NodeVersionAdapter;
459
460impl NodeVersionAdapter {
461 const SERVER_NAME: LanguageServerName =
462 LanguageServerName::new_static("package-version-server");
463}
464
465#[async_trait(?Send)]
466impl LspAdapter for NodeVersionAdapter {
467 fn name(&self) -> LanguageServerName {
468 Self::SERVER_NAME.clone()
469 }
470
471 async fn fetch_latest_server_version(
472 &self,
473 delegate: &dyn LspAdapterDelegate,
474 ) -> Result<Box<dyn 'static + Send + Any>> {
475 let release = latest_github_release(
476 "zed-industries/package-version-server",
477 true,
478 false,
479 delegate.http_client(),
480 )
481 .await?;
482 let os = match consts::OS {
483 "macos" => "apple-darwin",
484 "linux" => "unknown-linux-gnu",
485 "windows" => "pc-windows-msvc",
486 other => bail!("Running on unsupported os: {other}"),
487 };
488 let suffix = if consts::OS == "windows" {
489 ".zip"
490 } else {
491 ".tar.gz"
492 };
493 let asset_name = format!("{}-{}-{os}{suffix}", Self::SERVER_NAME, consts::ARCH);
494 let asset = release
495 .assets
496 .iter()
497 .find(|asset| asset.name == asset_name)
498 .with_context(|| format!("no asset found matching `{asset_name:?}`"))?;
499 Ok(Box::new(GitHubLspBinaryVersion {
500 name: release.tag_name,
501 url: asset.browser_download_url.clone(),
502 }))
503 }
504
505 async fn check_if_user_installed(
506 &self,
507 delegate: &dyn LspAdapterDelegate,
508 _: Arc<dyn LanguageToolchainStore>,
509 _: &AsyncApp,
510 ) -> Option<LanguageServerBinary> {
511 let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
512 Some(LanguageServerBinary {
513 path,
514 env: None,
515 arguments: Default::default(),
516 })
517 }
518
519 async fn fetch_server_binary(
520 &self,
521 latest_version: Box<dyn 'static + Send + Any>,
522 container_dir: PathBuf,
523 delegate: &dyn LspAdapterDelegate,
524 ) -> Result<LanguageServerBinary> {
525 let version = latest_version.downcast::<GitHubLspBinaryVersion>().unwrap();
526 let destination_path = container_dir.join(format!(
527 "{}-{}{}",
528 Self::SERVER_NAME,
529 version.name,
530 std::env::consts::EXE_SUFFIX
531 ));
532 let destination_container_path =
533 container_dir.join(format!("{}-{}-tmp", Self::SERVER_NAME, version.name));
534 if fs::metadata(&destination_path).await.is_err() {
535 let mut response = delegate
536 .http_client()
537 .get(&version.url, Default::default(), true)
538 .await
539 .context("downloading release")?;
540 if version.url.ends_with(".zip") {
541 extract_zip(&destination_container_path, response.body_mut()).await?;
542 } else if version.url.ends_with(".tar.gz") {
543 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
544 let archive = Archive::new(decompressed_bytes);
545 archive.unpack(&destination_container_path).await?;
546 }
547
548 fs::copy(
549 destination_container_path.join(format!(
550 "{}{}",
551 Self::SERVER_NAME,
552 std::env::consts::EXE_SUFFIX
553 )),
554 &destination_path,
555 )
556 .await?;
557 remove_matching(&container_dir, |entry| entry != destination_path).await;
558 }
559 Ok(LanguageServerBinary {
560 path: destination_path,
561 env: None,
562 arguments: Default::default(),
563 })
564 }
565
566 async fn cached_server_binary(
567 &self,
568 container_dir: PathBuf,
569 _delegate: &dyn LspAdapterDelegate,
570 ) -> Option<LanguageServerBinary> {
571 get_cached_version_server_binary(container_dir).await
572 }
573}
574
575async fn get_cached_version_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
576 maybe!(async {
577 let mut last = None;
578 let mut entries = fs::read_dir(&container_dir).await?;
579 while let Some(entry) = entries.next().await {
580 last = Some(entry?.path());
581 }
582
583 anyhow::Ok(LanguageServerBinary {
584 path: last.context("no cached binary")?,
585 env: None,
586 arguments: Default::default(),
587 })
588 })
589 .await
590 .log_err()
591}