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