1use anyhow::{Context as _, Result, anyhow, bail};
2use async_compression::futures::bufread::GzipDecoder;
3use async_tar::Archive;
4use futures::{AsyncReadExt, FutureExt as _, channel::oneshot, future::Shared};
5use http_client::{Host, HttpClient, Url};
6use log::Level;
7use semver::Version;
8use serde::Deserialize;
9use smol::io::BufReader;
10use smol::{fs, lock::Mutex};
11use std::fmt::Display;
12use std::{
13 env::{self, consts},
14 ffi::OsString,
15 io,
16 net::{IpAddr, Ipv4Addr},
17 path::{Path, PathBuf},
18 process::Output,
19 sync::Arc,
20};
21use util::ResultExt;
22use util::archive::extract_zip;
23
24const NODE_CA_CERTS_ENV_VAR: &str = "NODE_EXTRA_CA_CERTS";
25
26#[derive(Clone, Debug, Default, Eq, PartialEq)]
27pub struct NodeBinaryOptions {
28 pub allow_path_lookup: bool,
29 pub allow_binary_download: bool,
30 pub use_paths: Option<(PathBuf, PathBuf)>,
31}
32
33pub enum VersionStrategy<'a> {
34 /// Install if current version doesn't match pinned version
35 Pin(&'a str),
36 /// Install if current version is older than latest version
37 Latest(&'a str),
38}
39
40#[derive(Clone)]
41pub struct NodeRuntime(Arc<Mutex<NodeRuntimeState>>);
42
43struct NodeRuntimeState {
44 http: Arc<dyn HttpClient>,
45 instance: Option<Box<dyn NodeRuntimeTrait>>,
46 last_options: Option<NodeBinaryOptions>,
47 options: watch::Receiver<Option<NodeBinaryOptions>>,
48 shell_env_loaded: Shared<oneshot::Receiver<()>>,
49}
50
51impl NodeRuntime {
52 pub fn new(
53 http: Arc<dyn HttpClient>,
54 shell_env_loaded: Option<oneshot::Receiver<()>>,
55 options: watch::Receiver<Option<NodeBinaryOptions>>,
56 ) -> Self {
57 NodeRuntime(Arc::new(Mutex::new(NodeRuntimeState {
58 http,
59 instance: None,
60 last_options: None,
61 options,
62 shell_env_loaded: shell_env_loaded.unwrap_or(oneshot::channel().1).shared(),
63 })))
64 }
65
66 pub fn unavailable() -> Self {
67 NodeRuntime(Arc::new(Mutex::new(NodeRuntimeState {
68 http: Arc::new(http_client::BlockedHttpClient),
69 instance: None,
70 last_options: None,
71 options: watch::channel(Some(NodeBinaryOptions::default())).1,
72 shell_env_loaded: oneshot::channel().1.shared(),
73 })))
74 }
75
76 async fn instance(&self) -> Box<dyn NodeRuntimeTrait> {
77 let mut state = self.0.lock().await;
78
79 let options = loop {
80 if let Some(options) = state.options.borrow().as_ref() {
81 break options.clone();
82 }
83 match state.options.changed().await {
84 Ok(()) => {}
85 // failure case not cached
86 Err(err) => {
87 return Box::new(UnavailableNodeRuntime {
88 error_message: err.to_string().into(),
89 });
90 }
91 }
92 };
93
94 if state.last_options.as_ref() != Some(&options) {
95 state.instance.take();
96 }
97 if let Some(instance) = state.instance.as_ref() {
98 return instance.boxed_clone();
99 }
100
101 if let Some((node, npm)) = options.use_paths.as_ref() {
102 let instance = match SystemNodeRuntime::new(node.clone(), npm.clone()).await {
103 Ok(instance) => {
104 log::info!("using Node.js from `node.path` in settings: {:?}", instance);
105 Box::new(instance)
106 }
107 Err(err) => {
108 // failure case not cached, since it's cheap to check again
109 return Box::new(UnavailableNodeRuntime {
110 error_message: format!(
111 "failure checking Node.js from `node.path` in settings ({}): {:?}",
112 node.display(),
113 err
114 )
115 .into(),
116 });
117 }
118 };
119 state.instance = Some(instance.boxed_clone());
120 state.last_options = Some(options);
121 return instance;
122 }
123
124 let system_node_error = if options.allow_path_lookup {
125 state.shell_env_loaded.clone().await.ok();
126 match SystemNodeRuntime::detect().await {
127 Ok(instance) => {
128 log::info!("using Node.js found on PATH: {:?}", instance);
129 state.instance = Some(instance.boxed_clone());
130 state.last_options = Some(options);
131 return Box::new(instance);
132 }
133 Err(err) => Some(err),
134 }
135 } else {
136 None
137 };
138
139 let instance = if options.allow_binary_download {
140 let (log_level, why_using_managed) = match system_node_error {
141 Some(err @ DetectError::Other(_)) => (Level::Warn, err.to_string()),
142 Some(err @ DetectError::NotInPath(_)) => (Level::Info, err.to_string()),
143 None => (
144 Level::Info,
145 "`node.ignore_system_version` is `true` in settings".to_string(),
146 ),
147 };
148 match ManagedNodeRuntime::install_if_needed(&state.http).await {
149 Ok(instance) => {
150 log::log!(
151 log_level,
152 "using Zed managed Node.js at {} since {}",
153 instance.installation_path.display(),
154 why_using_managed
155 );
156 Box::new(instance) as Box<dyn NodeRuntimeTrait>
157 }
158 Err(err) => {
159 // failure case is cached, since downloading + installing may be expensive. The
160 // downside of this is that it may fail due to an intermittent network issue.
161 //
162 // TODO: Have `install_if_needed` indicate which failure cases are retryable
163 // and/or have shared tracking of when internet is available.
164 Box::new(UnavailableNodeRuntime {
165 error_message: format!(
166 "failure while downloading and/or installing Zed managed Node.js, \
167 restart Zed to retry: {}",
168 err
169 )
170 .into(),
171 }) as Box<dyn NodeRuntimeTrait>
172 }
173 }
174 } else if let Some(system_node_error) = system_node_error {
175 // failure case not cached, since it's cheap to check again
176 //
177 // TODO: When support is added for setting `options.allow_binary_download`, update this
178 // error message.
179 return Box::new(UnavailableNodeRuntime {
180 error_message: format!(
181 "failure while checking system Node.js from PATH: {}",
182 system_node_error
183 )
184 .into(),
185 });
186 } else {
187 // failure case is cached because it will always happen with these options
188 //
189 // TODO: When support is added for setting `options.allow_binary_download`, update this
190 // error message.
191 Box::new(UnavailableNodeRuntime {
192 error_message: "`node` settings do not allow any way to use Node.js"
193 .to_string()
194 .into(),
195 })
196 };
197
198 state.instance = Some(instance.boxed_clone());
199 state.last_options = Some(options);
200 instance
201 }
202
203 pub async fn binary_path(&self) -> Result<PathBuf> {
204 self.instance().await.binary_path()
205 }
206
207 pub async fn run_npm_subcommand(
208 &self,
209 directory: Option<&Path>,
210 subcommand: &str,
211 args: &[&str],
212 ) -> Result<Output> {
213 let http = self.0.lock().await.http.clone();
214 self.instance()
215 .await
216 .run_npm_subcommand(directory, http.proxy(), subcommand, args)
217 .await
218 }
219
220 pub async fn npm_package_installed_version(
221 &self,
222 local_package_directory: &Path,
223 name: &str,
224 ) -> Result<Option<String>> {
225 self.instance()
226 .await
227 .npm_package_installed_version(local_package_directory, name)
228 .await
229 }
230
231 pub async fn npm_package_latest_version(&self, name: &str) -> Result<String> {
232 let http = self.0.lock().await.http.clone();
233 let output = self
234 .instance()
235 .await
236 .run_npm_subcommand(
237 None,
238 http.proxy(),
239 "info",
240 &[
241 name,
242 "--json",
243 "--fetch-retry-mintimeout",
244 "2000",
245 "--fetch-retry-maxtimeout",
246 "5000",
247 "--fetch-timeout",
248 "5000",
249 ],
250 )
251 .await?;
252
253 let mut info: NpmInfo = serde_json::from_slice(&output.stdout)?;
254 info.dist_tags
255 .latest
256 .or_else(|| info.versions.pop())
257 .with_context(|| format!("no version found for npm package {name}"))
258 }
259
260 pub async fn npm_install_packages(
261 &self,
262 directory: &Path,
263 packages: &[(&str, &str)],
264 ) -> Result<()> {
265 if packages.is_empty() {
266 return Ok(());
267 }
268
269 let packages: Vec<_> = packages
270 .iter()
271 .map(|(name, version)| format!("{name}@{version}"))
272 .collect();
273
274 let mut arguments: Vec<_> = packages.iter().map(|p| p.as_str()).collect();
275 arguments.extend_from_slice(&[
276 "--save-exact",
277 "--fetch-retry-mintimeout",
278 "2000",
279 "--fetch-retry-maxtimeout",
280 "5000",
281 "--fetch-timeout",
282 "5000",
283 ]);
284
285 // This is also wrong because the directory is wrong.
286 self.run_npm_subcommand(Some(directory), "install", &arguments)
287 .await?;
288 Ok(())
289 }
290
291 pub async fn should_install_npm_package(
292 &self,
293 package_name: &str,
294 local_executable_path: &Path,
295 local_package_directory: &Path,
296 version_strategy: VersionStrategy<'_>,
297 ) -> bool {
298 // In the case of the local system not having the package installed,
299 // or in the instances where we fail to parse package.json data,
300 // we attempt to install the package.
301 if fs::metadata(local_executable_path).await.is_err() {
302 return true;
303 }
304
305 let Some(installed_version) = self
306 .npm_package_installed_version(local_package_directory, package_name)
307 .await
308 .log_err()
309 .flatten()
310 else {
311 return true;
312 };
313
314 let Some(installed_version) = Version::parse(&installed_version).log_err() else {
315 return true;
316 };
317
318 match version_strategy {
319 VersionStrategy::Pin(pinned_version) => {
320 let Some(pinned_version) = Version::parse(pinned_version).log_err() else {
321 return true;
322 };
323 installed_version != pinned_version
324 }
325 VersionStrategy::Latest(latest_version) => {
326 let Some(latest_version) = Version::parse(latest_version).log_err() else {
327 return true;
328 };
329 installed_version < latest_version
330 }
331 }
332 }
333}
334
335enum ArchiveType {
336 TarGz,
337 Zip,
338}
339
340#[derive(Debug, Deserialize)]
341#[serde(rename_all = "kebab-case")]
342pub struct NpmInfo {
343 #[serde(default)]
344 dist_tags: NpmInfoDistTags,
345 versions: Vec<String>,
346}
347
348#[derive(Debug, Deserialize, Default)]
349pub struct NpmInfoDistTags {
350 latest: Option<String>,
351}
352
353#[async_trait::async_trait]
354trait NodeRuntimeTrait: Send + Sync {
355 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait>;
356 fn binary_path(&self) -> Result<PathBuf>;
357
358 async fn run_npm_subcommand(
359 &self,
360 directory: Option<&Path>,
361 proxy: Option<&Url>,
362 subcommand: &str,
363 args: &[&str],
364 ) -> Result<Output>;
365
366 async fn npm_package_installed_version(
367 &self,
368 local_package_directory: &Path,
369 name: &str,
370 ) -> Result<Option<String>>;
371}
372
373#[derive(Clone)]
374struct ManagedNodeRuntime {
375 installation_path: PathBuf,
376}
377
378impl ManagedNodeRuntime {
379 const VERSION: &str = "v24.11.0";
380
381 #[cfg(not(windows))]
382 const NODE_PATH: &str = "bin/node";
383 #[cfg(windows)]
384 const NODE_PATH: &str = "node.exe";
385
386 #[cfg(not(windows))]
387 const NPM_PATH: &str = "bin/npm";
388 #[cfg(windows)]
389 const NPM_PATH: &str = "node_modules/npm/bin/npm-cli.js";
390
391 async fn install_if_needed(http: &Arc<dyn HttpClient>) -> Result<Self> {
392 log::info!("Node runtime install_if_needed");
393
394 let os = match consts::OS {
395 "macos" => "darwin",
396 "linux" => "linux",
397 "windows" => "win",
398 other => bail!("Running on unsupported os: {other}"),
399 };
400
401 let arch = match consts::ARCH {
402 "x86_64" => "x64",
403 "aarch64" => "arm64",
404 other => bail!("Running on unsupported architecture: {other}"),
405 };
406
407 let version = Self::VERSION;
408 let folder_name = format!("node-{version}-{os}-{arch}");
409 let node_containing_dir = paths::data_dir().join("node");
410 let node_dir = node_containing_dir.join(folder_name);
411 let node_binary = node_dir.join(Self::NODE_PATH);
412 let npm_file = node_dir.join(Self::NPM_PATH);
413 let node_ca_certs = env::var(NODE_CA_CERTS_ENV_VAR).unwrap_or_else(|_| String::new());
414
415 let valid = if fs::metadata(&node_binary).await.is_ok() {
416 let result = util::command::new_smol_command(&node_binary)
417 .env(NODE_CA_CERTS_ENV_VAR, node_ca_certs)
418 .arg(npm_file)
419 .arg("--version")
420 .args(["--cache".into(), node_dir.join("cache")])
421 .args(["--userconfig".into(), node_dir.join("blank_user_npmrc")])
422 .args(["--globalconfig".into(), node_dir.join("blank_global_npmrc")])
423 .output()
424 .await;
425 match result {
426 Ok(output) => {
427 if output.status.success() {
428 true
429 } else {
430 log::warn!(
431 "Zed managed Node.js binary at {} failed check with output: {:?}",
432 node_binary.display(),
433 output
434 );
435 false
436 }
437 }
438 Err(err) => {
439 log::warn!(
440 "Zed managed Node.js binary at {} failed check, so re-downloading it. \
441 Error: {}",
442 node_binary.display(),
443 err
444 );
445 false
446 }
447 }
448 } else {
449 false
450 };
451
452 if !valid {
453 _ = fs::remove_dir_all(&node_containing_dir).await;
454 fs::create_dir(&node_containing_dir)
455 .await
456 .context("error creating node containing dir")?;
457
458 let archive_type = match consts::OS {
459 "macos" | "linux" => ArchiveType::TarGz,
460 "windows" => ArchiveType::Zip,
461 other => bail!("Running on unsupported os: {other}"),
462 };
463
464 let version = Self::VERSION;
465 let file_name = format!(
466 "node-{version}-{os}-{arch}.{extension}",
467 extension = match archive_type {
468 ArchiveType::TarGz => "tar.gz",
469 ArchiveType::Zip => "zip",
470 }
471 );
472
473 let url = format!("https://nodejs.org/dist/{version}/{file_name}");
474 log::info!("Downloading Node.js binary from {url}");
475 let mut response = http
476 .get(&url, Default::default(), true)
477 .await
478 .context("error downloading Node binary tarball")?;
479 log::info!("Download of Node.js complete, extracting...");
480
481 let body = response.body_mut();
482 match archive_type {
483 ArchiveType::TarGz => {
484 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
485 let archive = Archive::new(decompressed_bytes);
486 archive.unpack(&node_containing_dir).await?;
487 }
488 ArchiveType::Zip => extract_zip(&node_containing_dir, body).await?,
489 }
490 log::info!("Extracted Node.js to {}", node_containing_dir.display())
491 }
492
493 // Note: Not in the `if !valid {}` so we can populate these for existing installations
494 _ = fs::create_dir(node_dir.join("cache")).await;
495 _ = fs::write(node_dir.join("blank_user_npmrc"), []).await;
496 _ = fs::write(node_dir.join("blank_global_npmrc"), []).await;
497
498 anyhow::Ok(ManagedNodeRuntime {
499 installation_path: node_dir,
500 })
501 }
502}
503
504fn path_with_node_binary_prepended(node_binary: &Path) -> Option<OsString> {
505 let existing_path = env::var_os("PATH");
506 let node_bin_dir = node_binary.parent().map(|dir| dir.as_os_str());
507 match (existing_path, node_bin_dir) {
508 (Some(existing_path), Some(node_bin_dir)) => {
509 if let Ok(joined) = env::join_paths(
510 [PathBuf::from(node_bin_dir)]
511 .into_iter()
512 .chain(env::split_paths(&existing_path)),
513 ) {
514 Some(joined)
515 } else {
516 Some(existing_path)
517 }
518 }
519 (Some(existing_path), None) => Some(existing_path),
520 (None, Some(node_bin_dir)) => Some(node_bin_dir.to_owned()),
521 _ => None,
522 }
523}
524
525#[async_trait::async_trait]
526impl NodeRuntimeTrait for ManagedNodeRuntime {
527 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
528 Box::new(self.clone())
529 }
530
531 fn binary_path(&self) -> Result<PathBuf> {
532 Ok(self.installation_path.join(Self::NODE_PATH))
533 }
534
535 async fn run_npm_subcommand(
536 &self,
537 directory: Option<&Path>,
538 proxy: Option<&Url>,
539 subcommand: &str,
540 args: &[&str],
541 ) -> Result<Output> {
542 let attempt = || async move {
543 let node_binary = self.installation_path.join(Self::NODE_PATH);
544 let npm_file = self.installation_path.join(Self::NPM_PATH);
545 let env_path = path_with_node_binary_prepended(&node_binary).unwrap_or_default();
546
547 anyhow::ensure!(
548 smol::fs::metadata(&node_binary).await.is_ok(),
549 "missing node binary file"
550 );
551 anyhow::ensure!(
552 smol::fs::metadata(&npm_file).await.is_ok(),
553 "missing npm file"
554 );
555
556 let node_ca_certs = env::var(NODE_CA_CERTS_ENV_VAR).unwrap_or_else(|_| String::new());
557
558 let mut command = util::command::new_smol_command(node_binary);
559 command.env("PATH", env_path);
560 command.env(NODE_CA_CERTS_ENV_VAR, node_ca_certs);
561 command.arg(npm_file).arg(subcommand);
562 command.arg(format!(
563 "--cache={}",
564 self.installation_path.join("cache").display()
565 ));
566 command.args([
567 "--userconfig".into(),
568 self.installation_path.join("blank_user_npmrc"),
569 ]);
570 command.args([
571 "--globalconfig".into(),
572 self.installation_path.join("blank_global_npmrc"),
573 ]);
574 command.args(args);
575 configure_npm_command(&mut command, directory, proxy);
576 command.output().await.map_err(|e| anyhow!("{e}"))
577 };
578
579 let mut output = attempt().await;
580 if output.is_err() {
581 output = attempt().await;
582 anyhow::ensure!(
583 output.is_ok(),
584 "failed to launch npm subcommand {subcommand} subcommand\nerr: {:?}",
585 output.err()
586 );
587 }
588
589 if let Ok(output) = &output {
590 anyhow::ensure!(
591 output.status.success(),
592 "failed to execute npm {subcommand} subcommand:\nstdout: {:?}\nstderr: {:?}",
593 String::from_utf8_lossy(&output.stdout),
594 String::from_utf8_lossy(&output.stderr)
595 );
596 }
597
598 output.map_err(|e| anyhow!("{e}"))
599 }
600 async fn npm_package_installed_version(
601 &self,
602 local_package_directory: &Path,
603 name: &str,
604 ) -> Result<Option<String>> {
605 read_package_installed_version(local_package_directory.join("node_modules"), name).await
606 }
607}
608
609#[derive(Debug, Clone)]
610pub struct SystemNodeRuntime {
611 node: PathBuf,
612 npm: PathBuf,
613 global_node_modules: PathBuf,
614 scratch_dir: PathBuf,
615}
616
617impl SystemNodeRuntime {
618 const MIN_VERSION: semver::Version = Version::new(22, 0, 0);
619 async fn new(node: PathBuf, npm: PathBuf) -> Result<Self> {
620 let output = util::command::new_smol_command(&node)
621 .arg("--version")
622 .output()
623 .await
624 .with_context(|| format!("running node from {:?}", node))?;
625 if !output.status.success() {
626 anyhow::bail!(
627 "failed to run node --version. stdout: {}, stderr: {}",
628 String::from_utf8_lossy(&output.stdout),
629 String::from_utf8_lossy(&output.stderr),
630 );
631 }
632 let version_str = String::from_utf8_lossy(&output.stdout);
633 let version = semver::Version::parse(version_str.trim().trim_start_matches('v'))?;
634 if version < Self::MIN_VERSION {
635 anyhow::bail!(
636 "node at {} is too old. want: {}, got: {}",
637 node.to_string_lossy(),
638 Self::MIN_VERSION,
639 version
640 )
641 }
642
643 let scratch_dir = paths::data_dir().join("node");
644 fs::create_dir(&scratch_dir).await.ok();
645 fs::create_dir(scratch_dir.join("cache")).await.ok();
646
647 let mut this = Self {
648 node,
649 npm,
650 global_node_modules: PathBuf::default(),
651 scratch_dir,
652 };
653 let output = this.run_npm_subcommand(None, None, "root", &["-g"]).await?;
654 this.global_node_modules =
655 PathBuf::from(String::from_utf8_lossy(&output.stdout).to_string());
656
657 Ok(this)
658 }
659
660 async fn detect() -> std::result::Result<Self, DetectError> {
661 let node = which::which("node").map_err(DetectError::NotInPath)?;
662 let npm = which::which("npm").map_err(DetectError::NotInPath)?;
663 Self::new(node, npm).await.map_err(DetectError::Other)
664 }
665}
666
667enum DetectError {
668 NotInPath(which::Error),
669 Other(anyhow::Error),
670}
671
672impl Display for DetectError {
673 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
674 match self {
675 DetectError::NotInPath(err) => {
676 write!(f, "system Node.js wasn't found on PATH: {}", err)
677 }
678 DetectError::Other(err) => {
679 write!(f, "checking system Node.js failed with error: {}", err)
680 }
681 }
682 }
683}
684
685#[async_trait::async_trait]
686impl NodeRuntimeTrait for SystemNodeRuntime {
687 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
688 Box::new(self.clone())
689 }
690
691 fn binary_path(&self) -> Result<PathBuf> {
692 Ok(self.node.clone())
693 }
694
695 async fn run_npm_subcommand(
696 &self,
697 directory: Option<&Path>,
698 proxy: Option<&Url>,
699 subcommand: &str,
700 args: &[&str],
701 ) -> anyhow::Result<Output> {
702 let node_ca_certs = env::var(NODE_CA_CERTS_ENV_VAR).unwrap_or_else(|_| String::new());
703 let mut command = util::command::new_smol_command(self.npm.clone());
704 let path = path_with_node_binary_prepended(&self.node).unwrap_or_default();
705 command
706 .env("PATH", path)
707 .env(NODE_CA_CERTS_ENV_VAR, node_ca_certs)
708 .arg(subcommand)
709 .arg(format!(
710 "--cache={}",
711 self.scratch_dir.join("cache").display()
712 ))
713 .args(args);
714 configure_npm_command(&mut command, directory, proxy);
715 let output = command.output().await?;
716 anyhow::ensure!(
717 output.status.success(),
718 "failed to execute npm {subcommand} subcommand:\nstdout: {:?}\nstderr: {:?}",
719 String::from_utf8_lossy(&output.stdout),
720 String::from_utf8_lossy(&output.stderr)
721 );
722 Ok(output)
723 }
724
725 async fn npm_package_installed_version(
726 &self,
727 local_package_directory: &Path,
728 name: &str,
729 ) -> Result<Option<String>> {
730 read_package_installed_version(local_package_directory.join("node_modules"), name).await
731 // todo: allow returning a globally installed version (requires callers not to hard-code the path)
732 }
733}
734
735pub async fn read_package_installed_version(
736 node_module_directory: PathBuf,
737 name: &str,
738) -> Result<Option<String>> {
739 let package_json_path = node_module_directory.join(name).join("package.json");
740
741 let mut file = match fs::File::open(package_json_path).await {
742 Ok(file) => file,
743 Err(err) => {
744 if err.kind() == io::ErrorKind::NotFound {
745 return Ok(None);
746 }
747
748 Err(err)?
749 }
750 };
751
752 #[derive(Deserialize)]
753 struct PackageJson {
754 version: String,
755 }
756
757 let mut contents = String::new();
758 file.read_to_string(&mut contents).await?;
759 let package_json: PackageJson = serde_json::from_str(&contents)?;
760 Ok(Some(package_json.version))
761}
762
763#[derive(Clone)]
764pub struct UnavailableNodeRuntime {
765 error_message: Arc<String>,
766}
767
768#[async_trait::async_trait]
769impl NodeRuntimeTrait for UnavailableNodeRuntime {
770 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
771 Box::new(self.clone())
772 }
773 fn binary_path(&self) -> Result<PathBuf> {
774 bail!("{}", self.error_message)
775 }
776
777 async fn run_npm_subcommand(
778 &self,
779 _: Option<&Path>,
780 _: Option<&Url>,
781 _: &str,
782 _: &[&str],
783 ) -> anyhow::Result<Output> {
784 bail!("{}", self.error_message)
785 }
786
787 async fn npm_package_installed_version(
788 &self,
789 _local_package_directory: &Path,
790 _: &str,
791 ) -> Result<Option<String>> {
792 bail!("{}", self.error_message)
793 }
794}
795
796fn configure_npm_command(
797 command: &mut smol::process::Command,
798 directory: Option<&Path>,
799 proxy: Option<&Url>,
800) {
801 if let Some(directory) = directory {
802 command.current_dir(directory);
803 command.args(["--prefix".into(), directory.to_path_buf()]);
804 }
805
806 if let Some(mut proxy) = proxy.cloned() {
807 // Map proxy settings from `http://localhost:10809` to `http://127.0.0.1:10809`
808 // NodeRuntime without environment information can not parse `localhost`
809 // correctly.
810 // TODO: map to `[::1]` if we are using ipv6
811 if matches!(proxy.host(), Some(Host::Domain(domain)) if domain.eq_ignore_ascii_case("localhost"))
812 {
813 // When localhost is a valid Host, so is `127.0.0.1`
814 let _ = proxy.set_ip_host(IpAddr::V4(Ipv4Addr::LOCALHOST));
815 }
816
817 command.args(["--proxy", proxy.as_str()]);
818 }
819
820 #[cfg(windows)]
821 {
822 // SYSTEMROOT is a critical environment variables for Windows.
823 if let Some(val) = env::var("SYSTEMROOT")
824 .context("Missing environment variable: SYSTEMROOT!")
825 .log_err()
826 {
827 command.env("SYSTEMROOT", val);
828 }
829 // Without ComSpec, the post-install will always fail.
830 if let Some(val) = env::var("ComSpec")
831 .context("Missing environment variable: ComSpec!")
832 .log_err()
833 {
834 command.env("ComSpec", val);
835 }
836 }
837}
838
839#[cfg(test)]
840mod tests {
841 use http_client::Url;
842
843 use super::configure_npm_command;
844
845 // Map localhost to 127.0.0.1
846 // NodeRuntime without environment information can not parse `localhost` correctly.
847 #[test]
848 fn test_configure_npm_command_map_localhost_proxy() {
849 const CASES: [(&str, &str); 4] = [
850 // Map localhost to 127.0.0.1
851 ("http://localhost:9090/", "http://127.0.0.1:9090/"),
852 ("https://google.com/", "https://google.com/"),
853 (
854 "http://username:password@proxy.thing.com:8080/",
855 "http://username:password@proxy.thing.com:8080/",
856 ),
857 // Test when localhost is contained within a different part of the URL
858 (
859 "http://username:localhost@localhost:8080/",
860 "http://username:localhost@127.0.0.1:8080/",
861 ),
862 ];
863
864 for (proxy, mapped_proxy) in CASES {
865 let mut dummy = smol::process::Command::new("");
866 let proxy = Url::parse(proxy).unwrap();
867 configure_npm_command(&mut dummy, None, Some(&proxy));
868 let proxy = dummy
869 .get_args()
870 .skip_while(|&arg| arg != "--proxy")
871 .skip(1)
872 .next();
873 let proxy = proxy.expect("Proxy was not passed to Command correctly");
874 assert_eq!(
875 proxy, mapped_proxy,
876 "Incorrectly mapped localhost to 127.0.0.1"
877 );
878 }
879 }
880}