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