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