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