1use anyhow::{anyhow, bail, Context, Result};
2use async_compression::futures::bufread::GzipDecoder;
3use async_tar::Archive;
4use futures::{future::Shared, FutureExt};
5use gpui::{executor::Background, Task};
6use parking_lot::Mutex;
7use serde::Deserialize;
8use smol::{fs, io::BufReader};
9use std::{
10 env::consts,
11 path::{Path, PathBuf},
12 sync::Arc,
13};
14use util::http::HttpClient;
15
16const VERSION: &str = "v18.15.0";
17
18#[derive(Deserialize)]
19#[serde(rename_all = "kebab-case")]
20pub struct NpmInfo {
21 #[serde(default)]
22 dist_tags: NpmInfoDistTags,
23 versions: Vec<String>,
24}
25
26#[derive(Deserialize, Default)]
27pub struct NpmInfoDistTags {
28 latest: Option<String>,
29}
30
31pub struct NodeRuntime {
32 http: Arc<dyn HttpClient>,
33 background: Arc<Background>,
34 installation_path: Mutex<Option<Shared<Task<Result<PathBuf, Arc<anyhow::Error>>>>>>,
35}
36
37impl NodeRuntime {
38 pub fn new(http: Arc<dyn HttpClient>, background: Arc<Background>) -> Arc<NodeRuntime> {
39 Arc::new(NodeRuntime {
40 http,
41 background,
42 installation_path: Mutex::new(None),
43 })
44 }
45
46 pub async fn binary_path(&self) -> Result<PathBuf> {
47 let installation_path = self.install_if_needed().await?;
48 Ok(installation_path.join("bin/node"))
49 }
50
51 pub async fn npm_package_latest_version(&self, name: &str) -> Result<String> {
52 let installation_path = self.install_if_needed().await?;
53 let node_binary = installation_path.join("bin/node");
54 let npm_file = installation_path.join("bin/npm");
55
56 let output = smol::process::Command::new(node_binary)
57 .arg(npm_file)
58 .args(["-fetch-retry-mintimeout", "2000"])
59 .args(["-fetch-retry-maxtimeout", "5000"])
60 .args(["-fetch-timeout", "5000"])
61 .args(["info", name, "--json"])
62 .output()
63 .await
64 .context("failed to run npm info")?;
65
66 if !output.status.success() {
67 Err(anyhow!(
68 "failed to execute npm info:\nstdout: {:?}\nstderr: {:?}",
69 String::from_utf8_lossy(&output.stdout),
70 String::from_utf8_lossy(&output.stderr)
71 ))?;
72 }
73
74 let mut info: NpmInfo = serde_json::from_slice(&output.stdout)?;
75 info.dist_tags
76 .latest
77 .or_else(|| info.versions.pop())
78 .ok_or_else(|| anyhow!("no version found for npm package {}", name))
79 }
80
81 pub async fn npm_install_packages(
82 &self,
83 packages: impl IntoIterator<Item = (&str, &str)>,
84 directory: &Path,
85 ) -> Result<()> {
86 let installation_path = self.install_if_needed().await?;
87 let node_binary = installation_path.join("bin/node");
88 let npm_file = installation_path.join("bin/npm");
89
90 let output = smol::process::Command::new(node_binary)
91 .arg(npm_file)
92 .args(["-fetch-retry-mintimeout", "2000"])
93 .args(["-fetch-retry-maxtimeout", "5000"])
94 .args(["-fetch-timeout", "5000"])
95 .arg("install")
96 .arg("--prefix")
97 .arg(directory)
98 .args(
99 packages
100 .into_iter()
101 .map(|(name, version)| format!("{name}@{version}")),
102 )
103 .output()
104 .await
105 .context("failed to run npm install")?;
106 if !output.status.success() {
107 Err(anyhow!(
108 "failed to execute npm install:\nstdout: {:?}\nstderr: {:?}",
109 String::from_utf8_lossy(&output.stdout),
110 String::from_utf8_lossy(&output.stderr)
111 ))?;
112 }
113 Ok(())
114 }
115
116 async fn install_if_needed(&self) -> Result<PathBuf> {
117 let task = self
118 .installation_path
119 .lock()
120 .get_or_insert_with(|| {
121 let http = self.http.clone();
122 self.background
123 .spawn(async move { Self::install(http).await.map_err(Arc::new) })
124 .shared()
125 })
126 .clone();
127
128 match task.await {
129 Ok(path) => Ok(path),
130 Err(error) => Err(anyhow!("{}", error)),
131 }
132 }
133
134 async fn install(http: Arc<dyn HttpClient>) -> Result<PathBuf> {
135 let arch = match consts::ARCH {
136 "x86_64" => "x64",
137 "aarch64" => "arm64",
138 other => bail!("Running on unsupported platform: {other}"),
139 };
140
141 let folder_name = format!("node-{VERSION}-darwin-{arch}");
142 let node_containing_dir = util::paths::SUPPORT_DIR.join("node");
143 let node_dir = node_containing_dir.join(folder_name);
144 let node_binary = node_dir.join("bin/node");
145
146 if fs::metadata(&node_binary).await.is_err() {
147 _ = fs::remove_dir_all(&node_containing_dir).await;
148 fs::create_dir(&node_containing_dir)
149 .await
150 .context("error creating node containing dir")?;
151
152 let file_name = format!("node-{VERSION}-darwin-{arch}.tar.gz");
153 let url = format!("https://nodejs.org/dist/{VERSION}/{file_name}");
154 let mut response = http
155 .get(&url, Default::default(), true)
156 .await
157 .context("error downloading Node binary tarball")?;
158
159 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
160 let archive = Archive::new(decompressed_bytes);
161 archive.unpack(&node_containing_dir).await?;
162 }
163
164 anyhow::Ok(node_dir)
165 }
166}