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::{HttpClient, Url};
6use semver::Version;
7use serde::Deserialize;
8use smol::io::BufReader;
9use smol::{fs, lock::Mutex};
10use std::{
11 env::{self, consts},
12 ffi::OsString,
13 io,
14 path::{Path, PathBuf},
15 process::{Output, Stdio},
16 sync::Arc,
17};
18use util::ResultExt;
19use util::archive::extract_zip;
20
21const NODE_CA_CERTS_ENV_VAR: &str = "NODE_EXTRA_CA_CERTS";
22
23#[derive(Clone, Debug, Default, Eq, PartialEq)]
24pub struct NodeBinaryOptions {
25 pub allow_path_lookup: bool,
26 pub allow_binary_download: bool,
27 pub use_paths: Option<(PathBuf, PathBuf)>,
28}
29
30#[derive(Clone)]
31pub struct NodeRuntime(Arc<Mutex<NodeRuntimeState>>);
32
33struct NodeRuntimeState {
34 http: Arc<dyn HttpClient>,
35 instance: Option<Box<dyn NodeRuntimeTrait>>,
36 last_options: Option<NodeBinaryOptions>,
37 options: async_watch::Receiver<Option<NodeBinaryOptions>>,
38 shell_env_loaded: Shared<oneshot::Receiver<()>>,
39}
40
41impl NodeRuntime {
42 pub fn new(
43 http: Arc<dyn HttpClient>,
44 shell_env_loaded: Option<oneshot::Receiver<()>>,
45 options: async_watch::Receiver<Option<NodeBinaryOptions>>,
46 ) -> Self {
47 NodeRuntime(Arc::new(Mutex::new(NodeRuntimeState {
48 http,
49 instance: None,
50 last_options: None,
51 options,
52 shell_env_loaded: shell_env_loaded.unwrap_or(oneshot::channel().1).shared(),
53 })))
54 }
55
56 pub fn unavailable() -> Self {
57 NodeRuntime(Arc::new(Mutex::new(NodeRuntimeState {
58 http: Arc::new(http_client::BlockedHttpClient),
59 instance: None,
60 last_options: None,
61 options: async_watch::channel(Some(NodeBinaryOptions::default())).1,
62 shell_env_loaded: oneshot::channel().1.shared(),
63 })))
64 }
65
66 async fn instance(&self) -> Result<Box<dyn NodeRuntimeTrait>> {
67 let mut state = self.0.lock().await;
68
69 while state.options.borrow().is_none() {
70 state.options.changed().await?;
71 }
72 let options = state.options.borrow().clone().unwrap();
73 if state.last_options.as_ref() != Some(&options) {
74 state.instance.take();
75 }
76 if let Some(instance) = state.instance.as_ref() {
77 return Ok(instance.boxed_clone());
78 }
79
80 if let Some((node, npm)) = options.use_paths.as_ref() {
81 let instance = SystemNodeRuntime::new(node.clone(), npm.clone()).await?;
82 state.instance = Some(instance.boxed_clone());
83 return Ok(instance);
84 }
85
86 if options.allow_path_lookup {
87 state.shell_env_loaded.clone().await.ok();
88 if let Some(instance) = SystemNodeRuntime::detect().await {
89 state.instance = Some(instance.boxed_clone());
90 return Ok(instance);
91 }
92 }
93
94 let instance = if options.allow_binary_download {
95 ManagedNodeRuntime::install_if_needed(&state.http).await?
96 } else {
97 Box::new(UnavailableNodeRuntime)
98 };
99
100 state.instance = Some(instance.boxed_clone());
101 return Ok(instance);
102 }
103
104 pub async fn binary_path(&self) -> Result<PathBuf> {
105 self.instance().await?.binary_path()
106 }
107
108 pub async fn run_npm_subcommand(
109 &self,
110 directory: &Path,
111 subcommand: &str,
112 args: &[&str],
113 ) -> Result<Output> {
114 let http = self.0.lock().await.http.clone();
115 self.instance()
116 .await?
117 .run_npm_subcommand(Some(directory), http.proxy(), subcommand, args)
118 .await
119 }
120
121 pub async fn npm_package_installed_version(
122 &self,
123 local_package_directory: &Path,
124 name: &str,
125 ) -> Result<Option<String>> {
126 self.instance()
127 .await?
128 .npm_package_installed_version(local_package_directory, name)
129 .await
130 }
131
132 pub async fn npm_package_latest_version(&self, name: &str) -> Result<String> {
133 let http = self.0.lock().await.http.clone();
134 let output = self
135 .instance()
136 .await?
137 .run_npm_subcommand(
138 None,
139 http.proxy(),
140 "info",
141 &[
142 name,
143 "--json",
144 "--fetch-retry-mintimeout",
145 "2000",
146 "--fetch-retry-maxtimeout",
147 "5000",
148 "--fetch-timeout",
149 "5000",
150 ],
151 )
152 .await?;
153
154 let mut info: NpmInfo = serde_json::from_slice(&output.stdout)?;
155 info.dist_tags
156 .latest
157 .or_else(|| info.versions.pop())
158 .with_context(|| format!("no version found for npm package {name}"))
159 }
160
161 pub async fn npm_install_packages(
162 &self,
163 directory: &Path,
164 packages: &[(&str, &str)],
165 ) -> Result<()> {
166 if packages.is_empty() {
167 return Ok(());
168 }
169
170 let packages: Vec<_> = packages
171 .iter()
172 .map(|(name, version)| format!("{name}@{version}"))
173 .collect();
174
175 let mut arguments: Vec<_> = packages.iter().map(|p| p.as_str()).collect();
176 arguments.extend_from_slice(&[
177 "--save-exact",
178 "--fetch-retry-mintimeout",
179 "2000",
180 "--fetch-retry-maxtimeout",
181 "5000",
182 "--fetch-timeout",
183 "5000",
184 ]);
185
186 // This is also wrong because the directory is wrong.
187 self.run_npm_subcommand(directory, "install", &arguments)
188 .await?;
189 Ok(())
190 }
191
192 pub async fn should_install_npm_package(
193 &self,
194 package_name: &str,
195 local_executable_path: &Path,
196 local_package_directory: &Path,
197 latest_version: &str,
198 ) -> bool {
199 // In the case of the local system not having the package installed,
200 // or in the instances where we fail to parse package.json data,
201 // we attempt to install the package.
202 if fs::metadata(local_executable_path).await.is_err() {
203 return true;
204 }
205
206 let Some(installed_version) = self
207 .npm_package_installed_version(local_package_directory, package_name)
208 .await
209 .log_err()
210 .flatten()
211 else {
212 return true;
213 };
214
215 let Some(installed_version) = Version::parse(&installed_version).log_err() else {
216 return true;
217 };
218 let Some(latest_version) = Version::parse(latest_version).log_err() else {
219 return true;
220 };
221
222 installed_version < latest_version
223 }
224}
225
226enum ArchiveType {
227 TarGz,
228 Zip,
229}
230
231#[derive(Debug, Deserialize)]
232#[serde(rename_all = "kebab-case")]
233pub struct NpmInfo {
234 #[serde(default)]
235 dist_tags: NpmInfoDistTags,
236 versions: Vec<String>,
237}
238
239#[derive(Debug, Deserialize, Default)]
240pub struct NpmInfoDistTags {
241 latest: Option<String>,
242}
243
244#[async_trait::async_trait]
245trait NodeRuntimeTrait: Send + Sync {
246 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait>;
247 fn binary_path(&self) -> Result<PathBuf>;
248
249 async fn run_npm_subcommand(
250 &self,
251 directory: Option<&Path>,
252 proxy: Option<&Url>,
253 subcommand: &str,
254 args: &[&str],
255 ) -> Result<Output>;
256
257 async fn npm_package_installed_version(
258 &self,
259 local_package_directory: &Path,
260 name: &str,
261 ) -> Result<Option<String>>;
262}
263
264#[derive(Clone)]
265struct ManagedNodeRuntime {
266 installation_path: PathBuf,
267}
268
269impl ManagedNodeRuntime {
270 const VERSION: &str = "v22.5.1";
271
272 #[cfg(not(windows))]
273 const NODE_PATH: &str = "bin/node";
274 #[cfg(windows)]
275 const NODE_PATH: &str = "node.exe";
276
277 #[cfg(not(windows))]
278 const NPM_PATH: &str = "bin/npm";
279 #[cfg(windows)]
280 const NPM_PATH: &str = "node_modules/npm/bin/npm-cli.js";
281
282 async fn install_if_needed(http: &Arc<dyn HttpClient>) -> Result<Box<dyn NodeRuntimeTrait>> {
283 log::info!("Node runtime install_if_needed");
284
285 let os = match consts::OS {
286 "macos" => "darwin",
287 "linux" => "linux",
288 "windows" => "win",
289 other => bail!("Running on unsupported os: {other}"),
290 };
291
292 let arch = match consts::ARCH {
293 "x86_64" => "x64",
294 "aarch64" => "arm64",
295 other => bail!("Running on unsupported architecture: {other}"),
296 };
297
298 let version = Self::VERSION;
299 let folder_name = format!("node-{version}-{os}-{arch}");
300 let node_containing_dir = paths::data_dir().join("node");
301 let node_dir = node_containing_dir.join(folder_name);
302 let node_binary = node_dir.join(Self::NODE_PATH);
303 let npm_file = node_dir.join(Self::NPM_PATH);
304 let node_ca_certs = env::var(NODE_CA_CERTS_ENV_VAR).unwrap_or_else(|_| String::new());
305
306 let result = util::command::new_smol_command(&node_binary)
307 .env_clear()
308 .env(NODE_CA_CERTS_ENV_VAR, node_ca_certs)
309 .arg(npm_file)
310 .arg("--version")
311 .stdin(Stdio::null())
312 .stdout(Stdio::null())
313 .stderr(Stdio::null())
314 .args(["--cache".into(), node_dir.join("cache")])
315 .args(["--userconfig".into(), node_dir.join("blank_user_npmrc")])
316 .args(["--globalconfig".into(), node_dir.join("blank_global_npmrc")])
317 .status()
318 .await;
319 let valid = matches!(result, Ok(status) if status.success());
320
321 if !valid {
322 _ = fs::remove_dir_all(&node_containing_dir).await;
323 fs::create_dir(&node_containing_dir)
324 .await
325 .context("error creating node containing dir")?;
326
327 let archive_type = match consts::OS {
328 "macos" | "linux" => ArchiveType::TarGz,
329 "windows" => ArchiveType::Zip,
330 other => bail!("Running on unsupported os: {other}"),
331 };
332
333 let version = Self::VERSION;
334 let file_name = format!(
335 "node-{version}-{os}-{arch}.{extension}",
336 extension = match archive_type {
337 ArchiveType::TarGz => "tar.gz",
338 ArchiveType::Zip => "zip",
339 }
340 );
341 let url = format!("https://nodejs.org/dist/{version}/{file_name}");
342 let mut response = http
343 .get(&url, Default::default(), true)
344 .await
345 .context("error downloading Node binary tarball")?;
346
347 let body = response.body_mut();
348 match archive_type {
349 ArchiveType::TarGz => {
350 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
351 let archive = Archive::new(decompressed_bytes);
352 archive.unpack(&node_containing_dir).await?;
353 }
354 ArchiveType::Zip => extract_zip(&node_containing_dir, body).await?,
355 }
356 }
357
358 // Note: Not in the `if !valid {}` so we can populate these for existing installations
359 _ = fs::create_dir(node_dir.join("cache")).await;
360 _ = fs::write(node_dir.join("blank_user_npmrc"), []).await;
361 _ = fs::write(node_dir.join("blank_global_npmrc"), []).await;
362
363 anyhow::Ok(Box::new(ManagedNodeRuntime {
364 installation_path: node_dir,
365 }))
366 }
367}
368
369fn path_with_node_binary_prepended(node_binary: &Path) -> Option<OsString> {
370 let existing_path = env::var_os("PATH");
371 let node_bin_dir = node_binary.parent().map(|dir| dir.as_os_str());
372 match (existing_path, node_bin_dir) {
373 (Some(existing_path), Some(node_bin_dir)) => {
374 if let Ok(joined) = env::join_paths(
375 [PathBuf::from(node_bin_dir)]
376 .into_iter()
377 .chain(env::split_paths(&existing_path)),
378 ) {
379 Some(joined)
380 } else {
381 Some(existing_path)
382 }
383 }
384 (Some(existing_path), None) => Some(existing_path),
385 (None, Some(node_bin_dir)) => Some(node_bin_dir.to_owned()),
386 _ => None,
387 }
388}
389
390#[async_trait::async_trait]
391impl NodeRuntimeTrait for ManagedNodeRuntime {
392 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
393 Box::new(self.clone())
394 }
395
396 fn binary_path(&self) -> Result<PathBuf> {
397 Ok(self.installation_path.join(Self::NODE_PATH))
398 }
399
400 async fn run_npm_subcommand(
401 &self,
402 directory: Option<&Path>,
403 proxy: Option<&Url>,
404 subcommand: &str,
405 args: &[&str],
406 ) -> Result<Output> {
407 let attempt = || async move {
408 let node_binary = self.installation_path.join(Self::NODE_PATH);
409 let npm_file = self.installation_path.join(Self::NPM_PATH);
410 let env_path = path_with_node_binary_prepended(&node_binary).unwrap_or_default();
411
412 anyhow::ensure!(
413 smol::fs::metadata(&node_binary).await.is_ok(),
414 "missing node binary file"
415 );
416 anyhow::ensure!(
417 smol::fs::metadata(&npm_file).await.is_ok(),
418 "missing npm file"
419 );
420
421 let node_ca_certs = env::var(NODE_CA_CERTS_ENV_VAR).unwrap_or_else(|_| String::new());
422
423 let mut command = util::command::new_smol_command(node_binary);
424 command.env_clear();
425 command.env("PATH", env_path);
426 command.env(NODE_CA_CERTS_ENV_VAR, node_ca_certs);
427 command.arg(npm_file).arg(subcommand);
428 command.args(["--cache".into(), self.installation_path.join("cache")]);
429 command.args([
430 "--userconfig".into(),
431 self.installation_path.join("blank_user_npmrc"),
432 ]);
433 command.args([
434 "--globalconfig".into(),
435 self.installation_path.join("blank_global_npmrc"),
436 ]);
437 command.args(args);
438 configure_npm_command(&mut command, directory, proxy);
439 command.output().await.map_err(|e| anyhow!("{e}"))
440 };
441
442 let mut output = attempt().await;
443 if output.is_err() {
444 output = attempt().await;
445 anyhow::ensure!(
446 output.is_ok(),
447 "failed to launch npm subcommand {subcommand} subcommand\nerr: {:?}",
448 output.err()
449 );
450 }
451
452 if let Ok(output) = &output {
453 anyhow::ensure!(
454 output.status.success(),
455 "failed to execute npm {subcommand} subcommand:\nstdout: {:?}\nstderr: {:?}",
456 String::from_utf8_lossy(&output.stdout),
457 String::from_utf8_lossy(&output.stderr)
458 );
459 }
460
461 output.map_err(|e| anyhow!("{e}"))
462 }
463 async fn npm_package_installed_version(
464 &self,
465 local_package_directory: &Path,
466 name: &str,
467 ) -> Result<Option<String>> {
468 read_package_installed_version(local_package_directory.join("node_modules"), name).await
469 }
470}
471
472#[derive(Clone)]
473pub struct SystemNodeRuntime {
474 node: PathBuf,
475 npm: PathBuf,
476 global_node_modules: PathBuf,
477 scratch_dir: PathBuf,
478}
479
480impl SystemNodeRuntime {
481 const MIN_VERSION: semver::Version = Version::new(20, 0, 0);
482 async fn new(node: PathBuf, npm: PathBuf) -> Result<Box<dyn NodeRuntimeTrait>> {
483 let output = util::command::new_smol_command(&node)
484 .arg("--version")
485 .output()
486 .await
487 .with_context(|| format!("running node from {:?}", node))?;
488 if !output.status.success() {
489 anyhow::bail!(
490 "failed to run node --version. stdout: {}, stderr: {}",
491 String::from_utf8_lossy(&output.stdout),
492 String::from_utf8_lossy(&output.stderr),
493 );
494 }
495 let version_str = String::from_utf8_lossy(&output.stdout);
496 let version = semver::Version::parse(version_str.trim().trim_start_matches('v'))?;
497 if version < Self::MIN_VERSION {
498 anyhow::bail!(
499 "node at {} is too old. want: {}, got: {}",
500 node.to_string_lossy(),
501 Self::MIN_VERSION,
502 version
503 )
504 }
505
506 let scratch_dir = paths::data_dir().join("node");
507 fs::create_dir(&scratch_dir).await.ok();
508 fs::create_dir(scratch_dir.join("cache")).await.ok();
509
510 let mut this = Self {
511 node,
512 npm,
513 global_node_modules: PathBuf::default(),
514 scratch_dir,
515 };
516 let output = this.run_npm_subcommand(None, None, "root", &["-g"]).await?;
517 this.global_node_modules =
518 PathBuf::from(String::from_utf8_lossy(&output.stdout).to_string());
519
520 Ok(Box::new(this))
521 }
522
523 async fn detect() -> Option<Box<dyn NodeRuntimeTrait>> {
524 let node = which::which("node").ok()?;
525 let npm = which::which("npm").ok()?;
526 Self::new(node, npm).await.log_err()
527 }
528}
529
530#[async_trait::async_trait]
531impl NodeRuntimeTrait for SystemNodeRuntime {
532 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
533 Box::new(self.clone())
534 }
535
536 fn binary_path(&self) -> Result<PathBuf> {
537 Ok(self.node.clone())
538 }
539
540 async fn run_npm_subcommand(
541 &self,
542 directory: Option<&Path>,
543 proxy: Option<&Url>,
544 subcommand: &str,
545 args: &[&str],
546 ) -> anyhow::Result<Output> {
547 let node_ca_certs = env::var(NODE_CA_CERTS_ENV_VAR).unwrap_or_else(|_| String::new());
548 let mut command = util::command::new_smol_command(self.npm.clone());
549 let path = path_with_node_binary_prepended(&self.node).unwrap_or_default();
550 command
551 .env_clear()
552 .env("PATH", path)
553 .env(NODE_CA_CERTS_ENV_VAR, node_ca_certs)
554 .arg(subcommand)
555 .args(["--cache".into(), self.scratch_dir.join("cache")])
556 .args(args);
557 configure_npm_command(&mut command, directory, proxy);
558 let output = command.output().await?;
559 anyhow::ensure!(
560 output.status.success(),
561 "failed to execute npm {subcommand} subcommand:\nstdout: {:?}\nstderr: {:?}",
562 String::from_utf8_lossy(&output.stdout),
563 String::from_utf8_lossy(&output.stderr)
564 );
565 Ok(output)
566 }
567
568 async fn npm_package_installed_version(
569 &self,
570 local_package_directory: &Path,
571 name: &str,
572 ) -> Result<Option<String>> {
573 read_package_installed_version(local_package_directory.join("node_modules"), name).await
574 // todo: allow returning a globally installed version (requires callers not to hard-code the path)
575 }
576}
577
578pub async fn read_package_installed_version(
579 node_module_directory: PathBuf,
580 name: &str,
581) -> Result<Option<String>> {
582 let package_json_path = node_module_directory.join(name).join("package.json");
583
584 let mut file = match fs::File::open(package_json_path).await {
585 Ok(file) => file,
586 Err(err) => {
587 if err.kind() == io::ErrorKind::NotFound {
588 return Ok(None);
589 }
590
591 Err(err)?
592 }
593 };
594
595 #[derive(Deserialize)]
596 struct PackageJson {
597 version: String,
598 }
599
600 let mut contents = String::new();
601 file.read_to_string(&mut contents).await?;
602 let package_json: PackageJson = serde_json::from_str(&contents)?;
603 Ok(Some(package_json.version))
604}
605
606pub struct UnavailableNodeRuntime;
607
608#[async_trait::async_trait]
609impl NodeRuntimeTrait for UnavailableNodeRuntime {
610 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
611 Box::new(UnavailableNodeRuntime)
612 }
613 fn binary_path(&self) -> Result<PathBuf> {
614 bail!("binary_path: no node runtime available")
615 }
616
617 async fn run_npm_subcommand(
618 &self,
619 _: Option<&Path>,
620 _: Option<&Url>,
621 _: &str,
622 _: &[&str],
623 ) -> anyhow::Result<Output> {
624 bail!("run_npm_subcommand: no node runtime available")
625 }
626
627 async fn npm_package_installed_version(
628 &self,
629 _local_package_directory: &Path,
630 _: &str,
631 ) -> Result<Option<String>> {
632 bail!("npm_package_installed_version: no node runtime available")
633 }
634}
635
636fn configure_npm_command(
637 command: &mut smol::process::Command,
638 directory: Option<&Path>,
639 proxy: Option<&Url>,
640) {
641 if let Some(directory) = directory {
642 command.current_dir(directory);
643 command.args(["--prefix".into(), directory.to_path_buf()]);
644 }
645
646 if let Some(proxy) = proxy {
647 // Map proxy settings from `http://localhost:10809` to `http://127.0.0.1:10809`
648 // NodeRuntime without environment information can not parse `localhost`
649 // correctly.
650 // TODO: map to `[::1]` if we are using ipv6
651 let proxy = proxy
652 .to_string()
653 .to_ascii_lowercase()
654 .replace("localhost", "127.0.0.1");
655
656 command.args(["--proxy", &proxy]);
657 }
658
659 #[cfg(windows)]
660 {
661 // SYSTEMROOT is a critical environment variables for Windows.
662 if let Some(val) = env::var("SYSTEMROOT")
663 .context("Missing environment variable: SYSTEMROOT!")
664 .log_err()
665 {
666 command.env("SYSTEMROOT", val);
667 }
668 // Without ComSpec, the post-install will always fail.
669 if let Some(val) = env::var("ComSpec")
670 .context("Missing environment variable: ComSpec!")
671 .log_err()
672 {
673 command.env("ComSpec", val);
674 }
675 }
676}