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, process::Command};
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#[cfg(windows)]
24use smol::process::windows::CommandExt;
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 let packages: Vec<_> = packages
165 .iter()
166 .map(|(name, version)| format!("{name}@{version}"))
167 .collect();
168
169 let mut arguments: Vec<_> = packages.iter().map(|p| p.as_str()).collect();
170 arguments.extend_from_slice(&[
171 "--save-exact",
172 "--fetch-retry-mintimeout",
173 "2000",
174 "--fetch-retry-maxtimeout",
175 "5000",
176 "--fetch-timeout",
177 "5000",
178 ]);
179
180 self.run_npm_subcommand(directory, "install", &arguments)
181 .await?;
182 Ok(())
183 }
184
185 pub async fn should_install_npm_package(
186 &self,
187 package_name: &str,
188 local_executable_path: &Path,
189 local_package_directory: &Path,
190 latest_version: &str,
191 ) -> bool {
192 // In the case of the local system not having the package installed,
193 // or in the instances where we fail to parse package.json data,
194 // we attempt to install the package.
195 if fs::metadata(local_executable_path).await.is_err() {
196 return true;
197 }
198
199 let Some(installed_version) = self
200 .npm_package_installed_version(local_package_directory, package_name)
201 .await
202 .log_err()
203 .flatten()
204 else {
205 return true;
206 };
207
208 let Some(installed_version) = Version::parse(&installed_version).log_err() else {
209 return true;
210 };
211 let Some(latest_version) = Version::parse(latest_version).log_err() else {
212 return true;
213 };
214
215 installed_version < latest_version
216 }
217}
218
219enum ArchiveType {
220 TarGz,
221 Zip,
222}
223
224#[derive(Debug, Deserialize)]
225#[serde(rename_all = "kebab-case")]
226pub struct NpmInfo {
227 #[serde(default)]
228 dist_tags: NpmInfoDistTags,
229 versions: Vec<String>,
230}
231
232#[derive(Debug, Deserialize, Default)]
233pub struct NpmInfoDistTags {
234 latest: Option<String>,
235}
236
237#[async_trait::async_trait]
238trait NodeRuntimeTrait: Send + Sync {
239 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait>;
240 fn binary_path(&self) -> Result<PathBuf>;
241
242 async fn run_npm_subcommand(
243 &self,
244 directory: Option<&Path>,
245 proxy: Option<&Uri>,
246 subcommand: &str,
247 args: &[&str],
248 ) -> Result<Output>;
249
250 async fn npm_package_installed_version(
251 &self,
252 local_package_directory: &Path,
253 name: &str,
254 ) -> Result<Option<String>>;
255}
256
257#[derive(Clone)]
258struct ManagedNodeRuntime {
259 installation_path: PathBuf,
260}
261
262impl ManagedNodeRuntime {
263 const VERSION: &str = "v22.5.1";
264
265 #[cfg(not(windows))]
266 const NODE_PATH: &str = "bin/node";
267 #[cfg(windows)]
268 const NODE_PATH: &str = "node.exe";
269
270 #[cfg(not(windows))]
271 const NPM_PATH: &str = "bin/npm";
272 #[cfg(windows)]
273 const NPM_PATH: &str = "node_modules/npm/bin/npm-cli.js";
274
275 async fn node_environment_path(&self) -> Result<OsString> {
276 let node_binary = self.installation_path.join(Self::NODE_PATH);
277 let mut env_path = vec![node_binary
278 .parent()
279 .expect("invalid node binary path")
280 .to_path_buf()];
281
282 if let Some(existing_path) = std::env::var_os("PATH") {
283 let mut paths = std::env::split_paths(&existing_path).collect::<Vec<_>>();
284 env_path.append(&mut paths);
285 }
286
287 std::env::join_paths(env_path).context("failed to create PATH env variable")
288 }
289
290 async fn install_if_needed(http: &Arc<dyn HttpClient>) -> Result<Box<dyn NodeRuntimeTrait>> {
291 log::info!("Node runtime install_if_needed");
292
293 let os = match consts::OS {
294 "macos" => "darwin",
295 "linux" => "linux",
296 "windows" => "win",
297 other => bail!("Running on unsupported os: {other}"),
298 };
299
300 let arch = match consts::ARCH {
301 "x86_64" => "x64",
302 "aarch64" => "arm64",
303 other => bail!("Running on unsupported architecture: {other}"),
304 };
305
306 let version = Self::VERSION;
307 let folder_name = format!("node-{version}-{os}-{arch}");
308 let node_containing_dir = paths::support_dir().join("node");
309 let node_dir = node_containing_dir.join(folder_name);
310 let node_binary = node_dir.join(Self::NODE_PATH);
311 let npm_file = node_dir.join(Self::NPM_PATH);
312
313 let mut command = Command::new(&node_binary);
314
315 command
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
326 #[cfg(windows)]
327 command.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
328
329 let result = command.status().await;
330 let valid = matches!(result, Ok(status) if status.success());
331
332 if !valid {
333 _ = fs::remove_dir_all(&node_containing_dir).await;
334 fs::create_dir(&node_containing_dir)
335 .await
336 .context("error creating node containing dir")?;
337
338 let archive_type = match consts::OS {
339 "macos" | "linux" => ArchiveType::TarGz,
340 "windows" => ArchiveType::Zip,
341 other => bail!("Running on unsupported os: {other}"),
342 };
343
344 let version = Self::VERSION;
345 let file_name = format!(
346 "node-{version}-{os}-{arch}.{extension}",
347 extension = match archive_type {
348 ArchiveType::TarGz => "tar.gz",
349 ArchiveType::Zip => "zip",
350 }
351 );
352 let url = format!("https://nodejs.org/dist/{version}/{file_name}");
353 let mut response = http
354 .get(&url, Default::default(), true)
355 .await
356 .context("error downloading Node binary tarball")?;
357
358 let body = response.body_mut();
359 match archive_type {
360 ArchiveType::TarGz => {
361 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
362 let archive = Archive::new(decompressed_bytes);
363 archive.unpack(&node_containing_dir).await?;
364 }
365 ArchiveType::Zip => archive::extract_zip(&node_containing_dir, body).await?,
366 }
367 }
368
369 // Note: Not in the `if !valid {}` so we can populate these for existing installations
370 _ = fs::create_dir(node_dir.join("cache")).await;
371 _ = fs::write(node_dir.join("blank_user_npmrc"), []).await;
372 _ = fs::write(node_dir.join("blank_global_npmrc"), []).await;
373
374 anyhow::Ok(Box::new(ManagedNodeRuntime {
375 installation_path: node_dir,
376 }))
377 }
378}
379
380#[async_trait::async_trait]
381impl NodeRuntimeTrait for ManagedNodeRuntime {
382 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
383 Box::new(self.clone())
384 }
385
386 fn binary_path(&self) -> Result<PathBuf> {
387 Ok(self.installation_path.join(Self::NODE_PATH))
388 }
389
390 async fn run_npm_subcommand(
391 &self,
392 directory: Option<&Path>,
393 proxy: Option<&Uri>,
394 subcommand: &str,
395 args: &[&str],
396 ) -> Result<Output> {
397 let attempt = || async move {
398 let node_binary = self.installation_path.join(Self::NODE_PATH);
399 let npm_file = self.installation_path.join(Self::NPM_PATH);
400 let env_path = self.node_environment_path().await?;
401
402 if smol::fs::metadata(&node_binary).await.is_err() {
403 return Err(anyhow!("missing node binary file"));
404 }
405
406 if smol::fs::metadata(&npm_file).await.is_err() {
407 return Err(anyhow!("missing npm file"));
408 }
409
410 let mut command = Command::new(node_binary);
411 command.env_clear();
412 command.env("PATH", env_path);
413 command.arg(npm_file).arg(subcommand);
414 command.args(["--cache".into(), self.installation_path.join("cache")]);
415 command.args([
416 "--userconfig".into(),
417 self.installation_path.join("blank_user_npmrc"),
418 ]);
419 command.args([
420 "--globalconfig".into(),
421 self.installation_path.join("blank_global_npmrc"),
422 ]);
423 command.args(args);
424 configure_npm_command(&mut command, directory, proxy);
425 command.output().await.map_err(|e| anyhow!("{e}"))
426 };
427
428 let mut output = attempt().await;
429 if output.is_err() {
430 output = attempt().await;
431 if output.is_err() {
432 return Err(anyhow!(
433 "failed to launch npm subcommand {subcommand} subcommand\nerr: {:?}",
434 output.err()
435 ));
436 }
437 }
438
439 if let Ok(output) = &output {
440 if !output.status.success() {
441 return Err(anyhow!(
442 "failed to execute npm {subcommand} subcommand:\nstdout: {:?}\nstderr: {:?}",
443 String::from_utf8_lossy(&output.stdout),
444 String::from_utf8_lossy(&output.stderr)
445 ));
446 }
447 }
448
449 output.map_err(|e| anyhow!("{e}"))
450 }
451 async fn npm_package_installed_version(
452 &self,
453 local_package_directory: &Path,
454 name: &str,
455 ) -> Result<Option<String>> {
456 read_package_installed_version(local_package_directory.join("node_modules"), name).await
457 }
458}
459
460#[derive(Clone)]
461pub struct SystemNodeRuntime {
462 node: PathBuf,
463 npm: PathBuf,
464 global_node_modules: PathBuf,
465 scratch_dir: PathBuf,
466}
467
468impl SystemNodeRuntime {
469 const MIN_VERSION: semver::Version = Version::new(18, 0, 0);
470 async fn new(node: PathBuf, npm: PathBuf) -> Result<Box<dyn NodeRuntimeTrait>> {
471 let output = Command::new(&node)
472 .arg("--version")
473 .output()
474 .await
475 .with_context(|| format!("running node from {:?}", node))?;
476 if !output.status.success() {
477 anyhow::bail!(
478 "failed to run node --version. stdout: {}, stderr: {}",
479 String::from_utf8_lossy(&output.stdout),
480 String::from_utf8_lossy(&output.stderr),
481 );
482 }
483 let version_str = String::from_utf8_lossy(&output.stdout);
484 let version = semver::Version::parse(version_str.trim().trim_start_matches('v'))?;
485 if version < Self::MIN_VERSION {
486 anyhow::bail!(
487 "node at {} is too old. want: {}, got: {}",
488 node.to_string_lossy(),
489 Self::MIN_VERSION,
490 version
491 )
492 }
493
494 let scratch_dir = paths::support_dir().join("node");
495 fs::create_dir(&scratch_dir).await.ok();
496 fs::create_dir(scratch_dir.join("cache")).await.ok();
497 fs::write(scratch_dir.join("blank_user_npmrc"), [])
498 .await
499 .ok();
500 fs::write(scratch_dir.join("blank_global_npmrc"), [])
501 .await
502 .ok();
503
504 let mut this = Self {
505 node,
506 npm,
507 global_node_modules: PathBuf::default(),
508 scratch_dir,
509 };
510 let output = this.run_npm_subcommand(None, None, "root", &["-g"]).await?;
511 this.global_node_modules =
512 PathBuf::from(String::from_utf8_lossy(&output.stdout).to_string());
513
514 Ok(Box::new(this))
515 }
516
517 async fn detect() -> Option<Box<dyn NodeRuntimeTrait>> {
518 let node = which::which("node").ok()?;
519 let npm = which::which("npm").ok()?;
520 Self::new(node, npm).await.log_err()
521 }
522}
523
524#[async_trait::async_trait]
525impl NodeRuntimeTrait for SystemNodeRuntime {
526 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
527 Box::new(self.clone())
528 }
529
530 fn binary_path(&self) -> Result<PathBuf> {
531 Ok(self.node.clone())
532 }
533
534 async fn run_npm_subcommand(
535 &self,
536 directory: Option<&Path>,
537 proxy: Option<&Uri>,
538 subcommand: &str,
539 args: &[&str],
540 ) -> anyhow::Result<Output> {
541 let mut command = Command::new(self.node.clone());
542 command
543 .env_clear()
544 .env("PATH", std::env::var_os("PATH").unwrap_or_default())
545 .arg(self.npm.clone())
546 .arg(subcommand)
547 .args(["--cache".into(), self.scratch_dir.join("cache")])
548 .args([
549 "--userconfig".into(),
550 self.scratch_dir.join("blank_user_npmrc"),
551 ])
552 .args([
553 "--globalconfig".into(),
554 self.scratch_dir.join("blank_global_npmrc"),
555 ])
556 .args(args);
557 configure_npm_command(&mut command, directory, proxy);
558 let output = command.output().await?;
559 if !output.status.success() {
560 return Err(anyhow!(
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 }
566
567 Ok(output)
568 }
569
570 async fn npm_package_installed_version(
571 &self,
572 local_package_directory: &Path,
573 name: &str,
574 ) -> Result<Option<String>> {
575 read_package_installed_version(local_package_directory.join("node_modules"), name).await
576 // todo: allow returning a globally installed version (requires callers not to hard-code the path)
577 }
578}
579
580async fn read_package_installed_version(
581 node_module_directory: PathBuf,
582 name: &str,
583) -> Result<Option<String>> {
584 let package_json_path = node_module_directory.join(name).join("package.json");
585
586 let mut file = match fs::File::open(package_json_path).await {
587 Ok(file) => file,
588 Err(err) => {
589 if err.kind() == io::ErrorKind::NotFound {
590 return Ok(None);
591 }
592
593 Err(err)?
594 }
595 };
596
597 #[derive(Deserialize)]
598 struct PackageJson {
599 version: String,
600 }
601
602 let mut contents = String::new();
603 file.read_to_string(&mut contents).await?;
604 let package_json: PackageJson = serde_json::from_str(&contents)?;
605 Ok(Some(package_json.version))
606}
607
608pub struct UnavailableNodeRuntime;
609
610#[async_trait::async_trait]
611impl NodeRuntimeTrait for UnavailableNodeRuntime {
612 fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
613 Box::new(UnavailableNodeRuntime)
614 }
615 fn binary_path(&self) -> Result<PathBuf> {
616 bail!("binary_path: no node runtime available")
617 }
618
619 async fn run_npm_subcommand(
620 &self,
621 _: Option<&Path>,
622 _: Option<&Uri>,
623 _: &str,
624 _: &[&str],
625 ) -> anyhow::Result<Output> {
626 bail!("run_npm_subcommand: no node runtime available")
627 }
628
629 async fn npm_package_installed_version(
630 &self,
631 _local_package_directory: &Path,
632 _: &str,
633 ) -> Result<Option<String>> {
634 bail!("npm_package_installed_version: no node runtime available")
635 }
636}
637
638fn configure_npm_command(command: &mut Command, directory: Option<&Path>, proxy: Option<&Uri>) {
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 command.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
674 }
675}