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