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;
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
26const VERSION: &str = "v22.5.1";
27
28#[cfg(not(windows))]
29const NODE_PATH: &str = "bin/node";
30#[cfg(windows)]
31const NODE_PATH: &str = "node.exe";
32
33#[cfg(not(windows))]
34const NPM_PATH: &str = "bin/npm";
35#[cfg(windows)]
36const NPM_PATH: &str = "node_modules/npm/bin/npm-cli.js";
37
38enum ArchiveType {
39 TarGz,
40 Zip,
41}
42
43#[derive(Debug, Deserialize)]
44#[serde(rename_all = "kebab-case")]
45pub struct NpmInfo {
46 #[serde(default)]
47 dist_tags: NpmInfoDistTags,
48 versions: Vec<String>,
49}
50
51#[derive(Debug, Deserialize, Default)]
52pub struct NpmInfoDistTags {
53 latest: Option<String>,
54}
55
56#[async_trait::async_trait]
57pub trait NodeRuntime: Send + Sync {
58 async fn binary_path(&self) -> Result<PathBuf>;
59 async fn node_environment_path(&self) -> Result<OsString>;
60
61 async fn run_npm_subcommand(
62 &self,
63 directory: Option<&Path>,
64 subcommand: &str,
65 args: &[&str],
66 ) -> Result<Output>;
67
68 async fn npm_package_latest_version(&self, name: &str) -> Result<String>;
69
70 async fn npm_install_packages(&self, directory: &Path, packages: &[(&str, &str)])
71 -> Result<()>;
72
73 async fn npm_package_installed_version(
74 &self,
75 local_package_directory: &Path,
76 name: &str,
77 ) -> Result<Option<String>>;
78
79 async fn should_install_npm_package(
80 &self,
81 package_name: &str,
82 local_executable_path: &Path,
83 local_package_directory: &Path,
84 latest_version: &str,
85 ) -> bool {
86 // In the case of the local system not having the package installed,
87 // or in the instances where we fail to parse package.json data,
88 // we attempt to install the package.
89 if fs::metadata(local_executable_path).await.is_err() {
90 return true;
91 }
92
93 let Some(installed_version) = self
94 .npm_package_installed_version(local_package_directory, package_name)
95 .await
96 .log_err()
97 .flatten()
98 else {
99 return true;
100 };
101
102 let Some(installed_version) = Version::parse(&installed_version).log_err() else {
103 return true;
104 };
105 let Some(latest_version) = Version::parse(latest_version).log_err() else {
106 return true;
107 };
108
109 installed_version < latest_version
110 }
111}
112
113pub struct RealNodeRuntime {
114 http: Arc<dyn HttpClient>,
115 installation_lock: Mutex<()>,
116}
117
118impl RealNodeRuntime {
119 pub fn new(http: Arc<dyn HttpClient>) -> Arc<dyn NodeRuntime> {
120 Arc::new(RealNodeRuntime {
121 http,
122 installation_lock: Mutex::new(()),
123 })
124 }
125
126 async fn install_if_needed(&self) -> Result<PathBuf> {
127 let _lock = self.installation_lock.lock().await;
128 log::info!("Node runtime install_if_needed");
129
130 let os = match consts::OS {
131 "macos" => "darwin",
132 "linux" => "linux",
133 "windows" => "win",
134 other => bail!("Running on unsupported os: {other}"),
135 };
136
137 let arch = match consts::ARCH {
138 "x86_64" => "x64",
139 "aarch64" => "arm64",
140 other => bail!("Running on unsupported architecture: {other}"),
141 };
142
143 let folder_name = format!("node-{VERSION}-{os}-{arch}");
144 let node_containing_dir = paths::support_dir().join("node");
145 let node_dir = node_containing_dir.join(folder_name);
146 let node_binary = node_dir.join(NODE_PATH);
147 let npm_file = node_dir.join(NPM_PATH);
148
149 let mut command = Command::new(&node_binary);
150
151 command
152 .env_clear()
153 .arg(npm_file)
154 .arg("--version")
155 .stdin(Stdio::null())
156 .stdout(Stdio::null())
157 .stderr(Stdio::null())
158 .args(["--cache".into(), node_dir.join("cache")])
159 .args(["--userconfig".into(), node_dir.join("blank_user_npmrc")])
160 .args(["--globalconfig".into(), node_dir.join("blank_global_npmrc")]);
161
162 #[cfg(windows)]
163 command.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
164
165 let result = command.status().await;
166 let valid = matches!(result, Ok(status) if status.success());
167
168 if !valid {
169 _ = fs::remove_dir_all(&node_containing_dir).await;
170 fs::create_dir(&node_containing_dir)
171 .await
172 .context("error creating node containing dir")?;
173
174 let archive_type = match consts::OS {
175 "macos" | "linux" => ArchiveType::TarGz,
176 "windows" => ArchiveType::Zip,
177 other => bail!("Running on unsupported os: {other}"),
178 };
179
180 let file_name = format!(
181 "node-{VERSION}-{os}-{arch}.{extension}",
182 extension = match archive_type {
183 ArchiveType::TarGz => "tar.gz",
184 ArchiveType::Zip => "zip",
185 }
186 );
187 let url = format!("https://nodejs.org/dist/{VERSION}/{file_name}");
188 let mut response = self
189 .http
190 .get(&url, Default::default(), true)
191 .await
192 .context("error downloading Node binary tarball")?;
193
194 let body = response.body_mut();
195 match archive_type {
196 ArchiveType::TarGz => {
197 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
198 let archive = Archive::new(decompressed_bytes);
199 archive.unpack(&node_containing_dir).await?;
200 }
201 ArchiveType::Zip => archive::extract_zip(&node_containing_dir, body).await?,
202 }
203 }
204
205 // Note: Not in the `if !valid {}` so we can populate these for existing installations
206 _ = fs::create_dir(node_dir.join("cache")).await;
207 _ = fs::write(node_dir.join("blank_user_npmrc"), []).await;
208 _ = fs::write(node_dir.join("blank_global_npmrc"), []).await;
209
210 anyhow::Ok(node_dir)
211 }
212}
213
214#[async_trait::async_trait]
215impl NodeRuntime for RealNodeRuntime {
216 async fn binary_path(&self) -> Result<PathBuf> {
217 let installation_path = self.install_if_needed().await?;
218 Ok(installation_path.join(NODE_PATH))
219 }
220
221 async fn node_environment_path(&self) -> Result<OsString> {
222 let installation_path = self.install_if_needed().await?;
223 let node_binary = installation_path.join(NODE_PATH);
224 let mut env_path = vec![node_binary
225 .parent()
226 .expect("invalid node binary path")
227 .to_path_buf()];
228
229 if let Some(existing_path) = std::env::var_os("PATH") {
230 let mut paths = std::env::split_paths(&existing_path).collect::<Vec<_>>();
231 env_path.append(&mut paths);
232 }
233
234 Ok(std::env::join_paths(env_path).context("failed to create PATH env variable")?)
235 }
236
237 async fn run_npm_subcommand(
238 &self,
239 directory: Option<&Path>,
240 subcommand: &str,
241 args: &[&str],
242 ) -> Result<Output> {
243 let attempt = || async move {
244 let installation_path = self.install_if_needed().await?;
245 let node_binary = installation_path.join(NODE_PATH);
246 let npm_file = installation_path.join(NPM_PATH);
247 let env_path = self.node_environment_path().await?;
248
249 if smol::fs::metadata(&node_binary).await.is_err() {
250 return Err(anyhow!("missing node binary file"));
251 }
252
253 if smol::fs::metadata(&npm_file).await.is_err() {
254 return Err(anyhow!("missing npm file"));
255 }
256
257 let mut command = Command::new(node_binary);
258 command.env_clear();
259 command.env("PATH", env_path);
260 command.arg(npm_file).arg(subcommand);
261 command.args(["--cache".into(), installation_path.join("cache")]);
262 command.args([
263 "--userconfig".into(),
264 installation_path.join("blank_user_npmrc"),
265 ]);
266 command.args([
267 "--globalconfig".into(),
268 installation_path.join("blank_global_npmrc"),
269 ]);
270 command.args(args);
271
272 if let Some(directory) = directory {
273 command.current_dir(directory);
274 command.args(["--prefix".into(), directory.to_path_buf()]);
275 }
276
277 if let Some(proxy) = self.http.proxy() {
278 // Map proxy settings from `http://localhost:10809` to `http://127.0.0.1:10809`
279 // NodeRuntime without environment information can not parse `localhost`
280 // correctly.
281 // TODO: map to `[::1]` if we are using ipv6
282 let proxy = proxy
283 .to_string()
284 .to_ascii_lowercase()
285 .replace("localhost", "127.0.0.1");
286
287 command.args(["--proxy", &proxy]);
288 }
289
290 #[cfg(windows)]
291 {
292 // SYSTEMROOT is a critical environment variables for Windows.
293 if let Some(val) = std::env::var("SYSTEMROOT")
294 .context("Missing environment variable: SYSTEMROOT!")
295 .log_err()
296 {
297 command.env("SYSTEMROOT", val);
298 }
299 // Without ComSpec, the post-install will always fail.
300 if let Some(val) = std::env::var("ComSpec")
301 .context("Missing environment variable: ComSpec!")
302 .log_err()
303 {
304 command.env("ComSpec", val);
305 }
306 command.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
307 }
308
309 command.output().await.map_err(|e| anyhow!("{e}"))
310 };
311
312 let mut output = attempt().await;
313 if output.is_err() {
314 output = attempt().await;
315 if output.is_err() {
316 return Err(anyhow!(
317 "failed to launch npm subcommand {subcommand} subcommand\nerr: {:?}",
318 output.err()
319 ));
320 }
321 }
322
323 if let Ok(output) = &output {
324 if !output.status.success() {
325 return Err(anyhow!(
326 "failed to execute npm {subcommand} subcommand:\nstdout: {:?}\nstderr: {:?}",
327 String::from_utf8_lossy(&output.stdout),
328 String::from_utf8_lossy(&output.stderr)
329 ));
330 }
331 }
332
333 output.map_err(|e| anyhow!("{e}"))
334 }
335
336 async fn npm_package_latest_version(&self, name: &str) -> Result<String> {
337 let output = self
338 .run_npm_subcommand(
339 None,
340 "info",
341 &[
342 name,
343 "--json",
344 "--fetch-retry-mintimeout",
345 "2000",
346 "--fetch-retry-maxtimeout",
347 "5000",
348 "--fetch-timeout",
349 "5000",
350 ],
351 )
352 .await?;
353
354 let mut info: NpmInfo = serde_json::from_slice(&output.stdout)?;
355 info.dist_tags
356 .latest
357 .or_else(|| info.versions.pop())
358 .ok_or_else(|| anyhow!("no version found for npm package {}", name))
359 }
360
361 async fn npm_package_installed_version(
362 &self,
363 local_package_directory: &Path,
364 name: &str,
365 ) -> Result<Option<String>> {
366 let mut package_json_path = local_package_directory.to_owned();
367 package_json_path.extend(["node_modules", name, "package.json"]);
368
369 let mut file = match fs::File::open(package_json_path).await {
370 Ok(file) => file,
371 Err(err) => {
372 if err.kind() == io::ErrorKind::NotFound {
373 return Ok(None);
374 }
375
376 Err(err)?
377 }
378 };
379
380 #[derive(Deserialize)]
381 struct PackageJson {
382 version: String,
383 }
384
385 let mut contents = String::new();
386 file.read_to_string(&mut contents).await?;
387 let package_json: PackageJson = serde_json::from_str(&contents)?;
388 Ok(Some(package_json.version))
389 }
390
391 async fn npm_install_packages(
392 &self,
393 directory: &Path,
394 packages: &[(&str, &str)],
395 ) -> Result<()> {
396 let packages: Vec<_> = packages
397 .iter()
398 .map(|(name, version)| format!("{name}@{version}"))
399 .collect();
400
401 let mut arguments: Vec<_> = packages.iter().map(|p| p.as_str()).collect();
402 arguments.extend_from_slice(&[
403 "--save-exact",
404 "--fetch-retry-mintimeout",
405 "2000",
406 "--fetch-retry-maxtimeout",
407 "5000",
408 "--fetch-timeout",
409 "5000",
410 ]);
411
412 self.run_npm_subcommand(Some(directory), "install", &arguments)
413 .await?;
414 Ok(())
415 }
416}
417
418pub struct FakeNodeRuntime;
419
420impl FakeNodeRuntime {
421 pub fn new() -> Arc<dyn NodeRuntime> {
422 Arc::new(Self)
423 }
424}
425
426#[async_trait::async_trait]
427impl NodeRuntime for FakeNodeRuntime {
428 async fn binary_path(&self) -> anyhow::Result<PathBuf> {
429 unreachable!()
430 }
431
432 async fn node_environment_path(&self) -> anyhow::Result<OsString> {
433 unreachable!()
434 }
435
436 async fn run_npm_subcommand(
437 &self,
438 _: Option<&Path>,
439 subcommand: &str,
440 args: &[&str],
441 ) -> anyhow::Result<Output> {
442 unreachable!("Should not run npm subcommand '{subcommand}' with args {args:?}")
443 }
444
445 async fn npm_package_latest_version(&self, name: &str) -> anyhow::Result<String> {
446 unreachable!("Should not query npm package '{name}' for latest version")
447 }
448
449 async fn npm_package_installed_version(
450 &self,
451 _local_package_directory: &Path,
452 name: &str,
453 ) -> Result<Option<String>> {
454 unreachable!("Should not query npm package '{name}' for installed version")
455 }
456
457 async fn npm_install_packages(
458 &self,
459 _: &Path,
460 packages: &[(&str, &str)],
461 ) -> anyhow::Result<()> {
462 unreachable!("Should not install packages {packages:?}")
463 }
464}
465
466// TODO: Remove this when headless binary can run node
467pub struct DummyNodeRuntime;
468
469impl DummyNodeRuntime {
470 pub fn new() -> Arc<dyn NodeRuntime> {
471 Arc::new(Self)
472 }
473}
474
475#[async_trait::async_trait]
476impl NodeRuntime for DummyNodeRuntime {
477 async fn binary_path(&self) -> anyhow::Result<PathBuf> {
478 anyhow::bail!("Dummy Node Runtime")
479 }
480
481 async fn node_environment_path(&self) -> anyhow::Result<OsString> {
482 anyhow::bail!("Dummy node runtime")
483 }
484
485 async fn run_npm_subcommand(
486 &self,
487 _: Option<&Path>,
488 _subcommand: &str,
489 _args: &[&str],
490 ) -> anyhow::Result<Output> {
491 anyhow::bail!("Dummy node runtime")
492 }
493
494 async fn npm_package_latest_version(&self, _name: &str) -> anyhow::Result<String> {
495 anyhow::bail!("Dummy node runtime")
496 }
497
498 async fn npm_package_installed_version(
499 &self,
500 _local_package_directory: &Path,
501 _name: &str,
502 ) -> Result<Option<String>> {
503 anyhow::bail!("Dummy node runtime")
504 }
505
506 async fn npm_install_packages(
507 &self,
508 _: &Path,
509 _packages: &[(&str, &str)],
510 ) -> anyhow::Result<()> {
511 anyhow::bail!("Dummy node runtime")
512 }
513}