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