mod archive; use anyhow::{Context, Result, anyhow, bail};pub use archive::extract_zip;use async_compression::futures::bufread::GzipDecoder;use async_tar::Archive;use futures::{AsyncReadExt, FutureExt as _, channel::oneshot, future::Shared};use http_client::{HttpClient, Url};use semver::Version;use serde::Deserialize;use smol::io::BufReader;use smol::{fs, lock::Mutex};use std::{    env::{self, consts},    ffi::OsString,    io,    path::{Path, PathBuf},    process::{Output, Stdio},    sync::Arc,};use util::ResultExt; const NODE_CA_CERTS_ENV_VAR: &str = "NODE_EXTRA_CA_CERTS"; #[derive(Clone, Debug, Default, Eq, PartialEq)]pub struct NodeBinaryOptions {    pub allow_path_lookup: bool,    pub allow_binary_download: bool,    pub use_paths: Option<(PathBuf, PathBuf)>,} #[derive(Clone)]pub struct NodeRuntime(Arc<Mutex<NodeRuntimeState>>); struct NodeRuntimeState {    http: Arc<dyn HttpClient>,    instance: Option<Box<dyn NodeRuntimeTrait>>,    last_options: Option<NodeBinaryOptions>,    options: async_watch::Receiver<Option<NodeBinaryOptions>>,    shell_env_loaded: Shared<oneshot::Receiver<()>>,} impl NodeRuntime {    pub fn new(        http: Arc<dyn HttpClient>,        shell_env_loaded: Option<oneshot::Receiver<()>>,        options: async_watch::Receiver<Option<NodeBinaryOptions>>,    ) -> Self {        NodeRuntime(Arc::new(Mutex::new(NodeRuntimeState {            http,            instance: None,            last_options: None,            options,            shell_env_loaded: shell_env_loaded.unwrap_or(oneshot::channel().1).shared(),        })))    }     pub fn unavailable() -> Self {        NodeRuntime(Arc::new(Mutex::new(NodeRuntimeState {            http: Arc::new(http_client::BlockedHttpClient),            instance: None,            last_options: None,            options: async_watch::channel(Some(NodeBinaryOptions::default())).1,            shell_env_loaded: oneshot::channel().1.shared(),        })))    }     async fn instance(&self) -> Result<Box<dyn NodeRuntimeTrait>> {        let mut state = self.0.lock().await;         while state.options.borrow().is_none() {            state.options.changed().await?;        }        let options = state.options.borrow().clone().unwrap();        if state.last_options.as_ref() != Some(&options) {            state.instance.take();        }        if let Some(instance) = state.instance.as_ref() {            return Ok(instance.boxed_clone());        }         if let Some((node, npm)) = options.use_paths.as_ref() {            let instance = SystemNodeRuntime::new(node.clone(), npm.clone()).await?;            state.instance = Some(instance.boxed_clone());            return Ok(instance);        }         if options.allow_path_lookup {            state.shell_env_loaded.clone().await.ok();            if let Some(instance) = SystemNodeRuntime::detect().await {                state.instance = Some(instance.boxed_clone());                return Ok(instance);            }        }         let instance = if options.allow_binary_download {            ManagedNodeRuntime::install_if_needed(&state.http).await?        } else {            Box::new(UnavailableNodeRuntime)        };         state.instance = Some(instance.boxed_clone());        return Ok(instance);    }     pub async fn binary_path(&self) -> Result<PathBuf> {        self.instance().await?.binary_path()    }     pub async fn run_npm_subcommand(        &self,        directory: &Path,        subcommand: &str,        args: &[&str],    ) -> Result<Output> {        let http = self.0.lock().await.http.clone();        self.instance()            .await?            .run_npm_subcommand(Some(directory), http.proxy(), subcommand, args)            .await    }     pub async fn npm_package_installed_version(        &self,        local_package_directory: &Path,        name: &str,    ) -> Result<Option<String>> {        self.instance()            .await?            .npm_package_installed_version(local_package_directory, name)            .await    }     pub async fn npm_package_latest_version(&self, name: &str) -> Result<String> {        let http = self.0.lock().await.http.clone();        let output = self            .instance()            .await?            .run_npm_subcommand(                None,                http.proxy(),                "info",                &[                    name,                    "--json",                    "--fetch-retry-mintimeout",                    "2000",                    "--fetch-retry-maxtimeout",                    "5000",                    "--fetch-timeout",                    "5000",                ],            )            .await?;         let mut info: NpmInfo = serde_json::from_slice(&output.stdout)?;        info.dist_tags            .latest            .or_else(|| info.versions.pop())            .ok_or_else(|| anyhow!("no version found for npm package {}", name))    }     pub async fn npm_install_packages(        &self,        directory: &Path,        packages: &[(&str, &str)],    ) -> Result<()> {        if packages.is_empty() {            return Ok(());        }         let packages: Vec<_> = packages            .iter()            .map(|(name, version)| format!("{name}@{version}"))            .collect();         let mut arguments: Vec<_> = packages.iter().map(|p| p.as_str()).collect();        arguments.extend_from_slice(&[            "--save-exact",            "--fetch-retry-mintimeout",            "2000",            "--fetch-retry-maxtimeout",            "5000",            "--fetch-timeout",            "5000",        ]);         // This is also wrong because the directory is wrong.        self.run_npm_subcommand(directory, "install", &arguments)            .await?;        Ok(())    }     pub async fn should_install_npm_package(        &self,        package_name: &str,        local_executable_path: &Path,        local_package_directory: &Path,        latest_version: &str,    ) -> bool {        // In the case of the local system not having the package installed,        // or in the instances where we fail to parse package.json data,        // we attempt to install the package.        if fs::metadata(local_executable_path).await.is_err() {            return true;        }         let Some(installed_version) = self            .npm_package_installed_version(local_package_directory, package_name)            .await            .log_err()            .flatten()        else {            return true;        };         let Some(installed_version) = Version::parse(&installed_version).log_err() else {            return true;        };        let Some(latest_version) = Version::parse(latest_version).log_err() else {            return true;        };         installed_version < latest_version    }} enum ArchiveType {    TarGz,    Zip,} #[derive(Debug, Deserialize)]#[serde(rename_all = "kebab-case")]pub struct NpmInfo {    #[serde(default)]    dist_tags: NpmInfoDistTags,    versions: Vec<String>,} #[derive(Debug, Deserialize, Default)]pub struct NpmInfoDistTags {    latest: Option<String>,} #[async_trait::async_trait]trait NodeRuntimeTrait: Send + Sync {    fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait>;    fn binary_path(&self) -> Result<PathBuf>;     async fn run_npm_subcommand(        &self,        directory: Option<&Path>,        proxy: Option<&Url>,        subcommand: &str,        args: &[&str],    ) -> Result<Output>;     async fn npm_package_installed_version(        &self,        local_package_directory: &Path,        name: &str,    ) -> Result<Option<String>>;} #[derive(Clone)]struct ManagedNodeRuntime {    installation_path: PathBuf,} impl ManagedNodeRuntime {    const VERSION: &str = "v22.5.1";     #[cfg(not(windows))]    const NODE_PATH: &str = "bin/node";    #[cfg(windows)]    const NODE_PATH: &str = "node.exe";     #[cfg(not(windows))]    const NPM_PATH: &str = "bin/npm";    #[cfg(windows)]    const NPM_PATH: &str = "node_modules/npm/bin/npm-cli.js";     async fn install_if_needed(http: &Arc<dyn HttpClient>) -> Result<Box<dyn NodeRuntimeTrait>> {        log::info!("Node runtime install_if_needed");         let os = match consts::OS {            "macos" => "darwin",            "linux" => "linux",            "windows" => "win",            other => bail!("Running on unsupported os: {other}"),        };         let arch = match consts::ARCH {            "x86_64" => "x64",            "aarch64" => "arm64",            other => bail!("Running on unsupported architecture: {other}"),        };         let version = Self::VERSION;        let folder_name = format!("node-{version}-{os}-{arch}");        let node_containing_dir = paths::data_dir().join("node");        let node_dir = node_containing_dir.join(folder_name);        let node_binary = node_dir.join(Self::NODE_PATH);        let npm_file = node_dir.join(Self::NPM_PATH);        let node_ca_certs = env::var(NODE_CA_CERTS_ENV_VAR).unwrap_or_else(|_| String::new());         let result = util::command::new_smol_command(&node_binary)            .env_clear()            .env(NODE_CA_CERTS_ENV_VAR, node_ca_certs)            .arg(npm_file)            .arg("--version")            .stdin(Stdio::null())            .stdout(Stdio::null())            .stderr(Stdio::null())            .args(["--cache".into(), node_dir.join("cache")])            .args(["--userconfig".into(), node_dir.join("blank_user_npmrc")])            .args(["--globalconfig".into(), node_dir.join("blank_global_npmrc")])            .status()            .await;        let valid = matches!(result, Ok(status) if status.success());         if !valid {            _ = fs::remove_dir_all(&node_containing_dir).await;            fs::create_dir(&node_containing_dir)                .await                .context("error creating node containing dir")?;             let archive_type = match consts::OS {                "macos" | "linux" => ArchiveType::TarGz,                "windows" => ArchiveType::Zip,                other => bail!("Running on unsupported os: {other}"),            };             let version = Self::VERSION;            let file_name = format!(                "node-{version}-{os}-{arch}.{extension}",                extension = match archive_type {                    ArchiveType::TarGz => "tar.gz",                    ArchiveType::Zip => "zip",                }            );            let url = format!("https://nodejs.org/dist/{version}/{file_name}");            let mut response = http                .get(&url, Default::default(), true)                .await                .context("error downloading Node binary tarball")?;             let body = response.body_mut();            match archive_type {                ArchiveType::TarGz => {                    let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));                    let archive = Archive::new(decompressed_bytes);                    archive.unpack(&node_containing_dir).await?;                }                ArchiveType::Zip => archive::extract_zip(&node_containing_dir, body).await?,            }        }         // Note: Not in the `if !valid {}` so we can populate these for existing installations        _ = fs::create_dir(node_dir.join("cache")).await;        _ = fs::write(node_dir.join("blank_user_npmrc"), []).await;        _ = fs::write(node_dir.join("blank_global_npmrc"), []).await;         anyhow::Ok(Box::new(ManagedNodeRuntime {            installation_path: node_dir,        }))    }} fn path_with_node_binary_prepended(node_binary: &Path) -> Option<OsString> {    let existing_path = env::var_os("PATH");    let node_bin_dir = node_binary.parent().map(|dir| dir.as_os_str());    match (existing_path, node_bin_dir) {        (Some(existing_path), Some(node_bin_dir)) => {            if let Ok(joined) = env::join_paths(                [PathBuf::from(node_bin_dir)]                    .into_iter()                    .chain(env::split_paths(&existing_path)),            ) {                Some(joined)            } else {                Some(existing_path)            }        }        (Some(existing_path), None) => Some(existing_path),        (None, Some(node_bin_dir)) => Some(node_bin_dir.to_owned()),        _ => None,    }} #[async_trait::async_trait]impl NodeRuntimeTrait for ManagedNodeRuntime {    fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {        Box::new(self.clone())    }     fn binary_path(&self) -> Result<PathBuf> {        Ok(self.installation_path.join(Self::NODE_PATH))    }     async fn run_npm_subcommand(        &self,        directory: Option<&Path>,        proxy: Option<&Url>,        subcommand: &str,        args: &[&str],    ) -> Result<Output> {        let attempt = || async move {            let node_binary = self.installation_path.join(Self::NODE_PATH);            let npm_file = self.installation_path.join(Self::NPM_PATH);            let env_path = path_with_node_binary_prepended(&node_binary).unwrap_or_default();             if smol::fs::metadata(&node_binary).await.is_err() {                return Err(anyhow!("missing node binary file"));            }             if smol::fs::metadata(&npm_file).await.is_err() {                return Err(anyhow!("missing npm file"));            }             let node_ca_certs = env::var(NODE_CA_CERTS_ENV_VAR).unwrap_or_else(|_| String::new());             let mut command = util::command::new_smol_command(node_binary);            command.env_clear();            command.env("PATH", env_path);            command.env(NODE_CA_CERTS_ENV_VAR, node_ca_certs);            command.arg(npm_file).arg(subcommand);            command.args(["--cache".into(), self.installation_path.join("cache")]);            command.args([                "--userconfig".into(),                self.installation_path.join("blank_user_npmrc"),            ]);            command.args([                "--globalconfig".into(),                self.installation_path.join("blank_global_npmrc"),            ]);            command.args(args);            configure_npm_command(&mut command, directory, proxy);            command.output().await.map_err(|e| anyhow!("{e}"))        };         let mut output = attempt().await;        if output.is_err() {            output = attempt().await;            if output.is_err() {                return Err(anyhow!(                    "failed to launch npm subcommand {subcommand} subcommand\nerr: {:?}",                    output.err()                ));            }        }         if let Ok(output) = &output {            if !output.status.success() {                return Err(anyhow!(                    "failed to execute npm {subcommand} subcommand:\nstdout: {:?}\nstderr: {:?}",                    String::from_utf8_lossy(&output.stdout),                    String::from_utf8_lossy(&output.stderr)                ));            }        }         output.map_err(|e| anyhow!("{e}"))    }    async fn npm_package_installed_version(        &self,        local_package_directory: &Path,        name: &str,    ) -> Result<Option<String>> {        read_package_installed_version(local_package_directory.join("node_modules"), name).await    }} #[derive(Clone)]pub struct SystemNodeRuntime {    node: PathBuf,    npm: PathBuf,    global_node_modules: PathBuf,    scratch_dir: PathBuf,} impl SystemNodeRuntime {    const MIN_VERSION: semver::Version = Version::new(20, 0, 0);    async fn new(node: PathBuf, npm: PathBuf) -> Result<Box<dyn NodeRuntimeTrait>> {        let output = util::command::new_smol_command(&node)            .arg("--version")            .output()            .await            .with_context(|| format!("running node from {:?}", node))?;        if !output.status.success() {            anyhow::bail!(                "failed to run node --version. stdout: {}, stderr: {}",                String::from_utf8_lossy(&output.stdout),                String::from_utf8_lossy(&output.stderr),            );        }        let version_str = String::from_utf8_lossy(&output.stdout);        let version = semver::Version::parse(version_str.trim().trim_start_matches('v'))?;        if version < Self::MIN_VERSION {

Lines 1–500 of 681. Load more