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