fix(engines): store & link engines correctly

Fixes issues with how engines were stored
which resulted in errors. Also makes outdated
linkers get updated.

src/cli/reporters.rs

@@ -99,31 +99,29 @@ impl<W> CliReporter<W> {
 	}
 }
 
-pub struct CliDownloadProgressReporter<'a, W> {
+pub struct CliDownloadProgressReporter<W> {
-	root_reporter: &'a CliReporter<W>,
+	root_reporter: Arc<CliReporter<W>>,
 	name: String,
 	progress: OnceLock<ProgressBar>,
 	set_progress: Once,
 }
 
-impl<'a, W: Write + Send + Sync + 'static> DownloadsReporter<'a> for CliReporter<W> {
+impl<W: Write + Send + Sync + 'static> DownloadsReporter for CliReporter<W> {
-	type DownloadProgressReporter = CliDownloadProgressReporter<'a, W>;
+	type DownloadProgressReporter = CliDownloadProgressReporter<W>;
 
-	fn report_download<'b>(&'a self, name: &'b str) -> Self::DownloadProgressReporter {
+	fn report_download<'b>(self: Arc<Self>, name: String) -> Self::DownloadProgressReporter {
 		self.root_progress.inc_length(1);
 
 		CliDownloadProgressReporter {
 			root_reporter: self,
-			name: name.to_string(),
+			name,
 			progress: OnceLock::new(),
 			set_progress: Once::new(),
 		}
 	}
 }
 
-impl<W: Write + Send + Sync + 'static> DownloadProgressReporter
+impl<W: Write + Send + Sync + 'static> DownloadProgressReporter for CliDownloadProgressReporter<W> {
-	for CliDownloadProgressReporter<'_, W>
-{
 	fn report_start(&self) {
 		let progress = self.root_reporter.multi_progress.add(ProgressBar::new(0));
 		progress.set_style(self.root_reporter.child_style.clone());
@@ -171,16 +169,16 @@ impl<W: Write + Send + Sync + 'static> DownloadProgressReporter
 	}
 }
 
-pub struct CliPatchProgressReporter<'a, W> {
+pub struct CliPatchProgressReporter<W> {
-	root_reporter: &'a CliReporter<W>,
+	root_reporter: Arc<CliReporter<W>>,
 	name: String,
 	progress: ProgressBar,
 }
 
-impl<'a, W: Write + Send + Sync + 'static> PatchesReporter<'a> for CliReporter<W> {
+impl<W: Write + Send + Sync + 'static> PatchesReporter for CliReporter<W> {
-	type PatchProgressReporter = CliPatchProgressReporter<'a, W>;
+	type PatchProgressReporter = CliPatchProgressReporter<W>;
 
-	fn report_patch<'b>(&'a self, name: &'b str) -> Self::PatchProgressReporter {
+	fn report_patch(self: Arc<Self>, name: String) -> Self::PatchProgressReporter {
 		let progress = self.multi_progress.add(ProgressBar::new(0));
 		progress.set_style(self.child_style.clone());
 		progress.set_message(format!("- {name}"));
@@ -195,7 +193,7 @@ impl<'a, W: Write + Send + Sync + 'static> PatchesReporter<'a> for CliReporter<W
 	}
 }
 
-impl<W: Write + Send + Sync + 'static> PatchProgressReporter for CliPatchProgressReporter<'_, W> {
+impl<W: Write + Send + Sync + 'static> PatchProgressReporter for CliPatchProgressReporter<W> {
 	fn report_done(&self) {
 		if self.progress.is_hidden() {
 			writeln!(

src/cli/version.rs

@@ -3,6 +3,7 @@ use crate::cli::{
 	config::{read_config, write_config, CliConfig},
 	files::make_executable,
 	home_dir,
+	reporters::run_with_reporter,
 };
 use anyhow::Context;
 use colored::Colorize;
@@ -15,11 +16,13 @@ use pesde::{
 		},
 		EngineKind,
 	},
+	reporters::DownloadsReporter,
 	version_matches,
 };
 use semver::{Version, VersionReq};
 use std::{
 	collections::BTreeSet,
+	env::current_exe,
 	path::{Path, PathBuf},
 	sync::Arc,
 };
@@ -159,28 +162,25 @@ pub async fn get_or_download_engine(
 		.await
 		.context("failed to read engines directory")?;
 
-	let mut matching_versions = BTreeSet::new();
+	let mut installed_versions = BTreeSet::new();
 
 	while let Some(entry) = read_dir.next_entry().await? {
 		let path = entry.path();
 
-		#[cfg(windows)]
+		let Some(version) = path.file_name().and_then(|s| s.to_str()) else {
-		let version = path.file_stem();
-		#[cfg(not(windows))]
-		let version = path.file_name();
-
-		let Some(version) = version.and_then(|s| s.to_str()) else {
 			continue;
 		};
 
 		if let Ok(version) = Version::parse(version) {
-			if version_matches(&version, &req) {
+			installed_versions.insert(version);
-				matching_versions.insert(version);
-			}
 		}
 	}
 
-	if let Some(version) = matching_versions.pop_last() {
+	let max_matching = installed_versions
+		.iter()
+		.filter(|v| version_matches(v, &req))
+		.last();
+	if let Some(version) = max_matching {
 		return Ok(path
 			.join(version.to_string())
 			.join(source.expected_file_name())
@@ -198,40 +198,66 @@ pub async fn get_or_download_engine(
 		.context("failed to resolve versions")?;
 	let (version, engine_ref) = versions.pop_last().context("no matching versions found")?;
 
+	let path = path.join(version.to_string());
+
+	fs::create_dir_all(&path)
+		.await
+		.context("failed to create engine container folder")?;
+
 	let path = path
-		.join(version.to_string())
 		.join(source.expected_file_name())
 		.with_extension(std::env::consts::EXE_EXTENSION);
 
-	let archive = source
-		.download(
-			&engine_ref,
-			&DownloadOptions {
-				reqwest: reqwest.clone(),
-				reporter: Arc::new(()),
-				version,
-			},
-		)
-		.await
-		.context("failed to download engine")?;
-
 	let mut file = fs::File::create(&path)
 		.await
 		.context("failed to create new file")?;
-	tokio::io::copy(
+
-		&mut archive
+	run_with_reporter(|_, root_progress, reporter| async {
-			.find_executable(source.expected_file_name())
+		let root_progress = root_progress;
+
+		root_progress.set_message("download");
+
+		let reporter = reporter.report_download(format!("{engine} v{version}"));
+
+		let archive = source
+			.download(
+				&engine_ref,
+				&DownloadOptions {
+					reqwest: reqwest.clone(),
+					reporter: Arc::new(reporter),
+					version: version.clone(),
+				},
+			)
 			.await
-			.context("failed to find executable")?,
+			.context("failed to download engine")?;
-		&mut file,
+
-	)
+		tokio::io::copy(
-	.await
+			&mut archive
-	.context("failed to write to file")?;
+				.find_executable(source.expected_file_name())
+				.await
+				.context("failed to find executable")?,
+			&mut file,
+		)
+		.await
+		.context("failed to write to file")?;
+
+		Ok::<_, anyhow::Error>(())
+	})
+	.await?;
 
 	make_executable(&path)
 		.await
 		.context("failed to make downloaded version executable")?;
 
+	// replace the executable if there isn't any installed, or the one installed is out of date
+	if installed_versions.pop_last().is_none_or(|v| version > v) {
+		replace_bin_exe(
+			engine,
+			&current_exe().context("failed to get current exe path")?,
+		)
+		.await?;
+	}
+
 	Ok(path)
 }
 

src/download.rs

@@ -29,7 +29,7 @@ pub(crate) struct DownloadGraphOptions<Reporter> {
 
 impl<Reporter> DownloadGraphOptions<Reporter>
 where
-	Reporter: for<'a> DownloadsReporter<'a> + Send + Sync + 'static,
+	Reporter: DownloadsReporter + Send + Sync + 'static,
 {
 	/// Creates a new download options with the given reqwest client and reporter.
 	pub(crate) fn new(reqwest: reqwest::Client) -> Self {
@@ -85,7 +85,7 @@ impl Project {
 		errors::DownloadGraphError,
 	>
 	where
-		Reporter: for<'a> DownloadsReporter<'a> + Send + Sync + 'static,
+		Reporter: DownloadsReporter + Send + Sync + 'static,
 	{
 		let DownloadGraphOptions {
 			reqwest,
@@ -111,8 +111,8 @@ impl Project {
 
 				async move {
 					let progress_reporter = reporter
-						.as_deref()
+						.clone()
-						.map(|reporter| reporter.report_download(&package_id.to_string()));
+						.map(|reporter| reporter.report_download(package_id.to_string()));
 
 					let _permit = semaphore.acquire().await;
 

src/download_and_link.rs

@@ -81,7 +81,7 @@ pub struct DownloadAndLinkOptions<Reporter = (), Hooks = ()> {
 
 impl<Reporter, Hooks> DownloadAndLinkOptions<Reporter, Hooks>
 where
-	Reporter: for<'a> DownloadsReporter<'a> + Send + Sync + 'static,
+	Reporter: DownloadsReporter + Send + Sync + 'static,
 	Hooks: DownloadAndLinkHooks + Send + Sync + 'static,
 {
 	/// Creates a new download options with the given reqwest client and reporter.
@@ -149,7 +149,7 @@ impl Project {
 		options: DownloadAndLinkOptions<Reporter, Hooks>,
 	) -> Result<DependencyGraphWithTarget, errors::DownloadAndLinkError<Hooks::Error>>
 	where
-		Reporter: for<'a> DownloadsReporter<'a> + 'static,
+		Reporter: DownloadsReporter + 'static,
 		Hooks: DownloadAndLinkHooks + 'static,
 	{
 		let DownloadAndLinkOptions {

src/engine/source/archive.rs

@@ -53,22 +53,22 @@ impl FromStr for ArchiveInfo {
 	}
 }
 
+pub(crate) type ArchiveReader = Pin<Box<dyn AsyncBufRead>>;
+
 /// An archive
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Archive {
-pub struct Archive<R: AsyncBufRead + 'static> {
 	pub(crate) info: ArchiveInfo,
-	pub(crate) reader: R,
+	pub(crate) reader: ArchiveReader,
 }
 
-#[derive(Debug)]
+enum TarReader {
-enum TarReader<R: AsyncBufRead> {
+	Gzip(async_compression::tokio::bufread::GzipDecoder<ArchiveReader>),
-	Gzip(async_compression::tokio::bufread::GzipDecoder<R>),
+	Plain(ArchiveReader),
-	Plain(R),
 }
 
 // TODO: try to see if we can avoid the unsafe blocks
 
-impl<R: AsyncBufRead> AsyncRead for TarReader<R> {
+impl AsyncRead for TarReader {
 	fn poll_read(
 		self: Pin<&mut Self>,
 		cx: &mut Context<'_>,
@@ -83,8 +83,8 @@ impl<R: AsyncBufRead> AsyncRead for TarReader<R> {
 	}
 }
 
-enum ArchiveEntryInner<R: AsyncBufRead + 'static> {
+enum ArchiveEntryInner {
-	Tar(tokio_tar::Entry<tokio_tar::Archive<TarReader<Pin<Box<R>>>>>),
+	Tar(tokio_tar::Entry<tokio_tar::Archive<TarReader>>),
 	Zip {
 		archive: *mut async_zip::tokio::read::seek::ZipFileReader<std::io::Cursor<Vec<u8>>>,
 		reader: ManuallyDrop<
@@ -99,7 +99,7 @@ enum ArchiveEntryInner<R: AsyncBufRead + 'static> {
 	},
 }
 
-impl<R: AsyncBufRead> Drop for ArchiveEntryInner<R> {
+impl Drop for ArchiveEntryInner {
 	fn drop(&mut self) {
 		match self {
 			Self::Tar(_) => {}
@@ -112,9 +112,9 @@ impl<R: AsyncBufRead> Drop for ArchiveEntryInner<R> {
 }
 
 /// An entry in an archive. Usually the executable
-pub struct ArchiveEntry<R: AsyncBufRead + 'static>(ArchiveEntryInner<R>);
+pub struct ArchiveEntry(ArchiveEntryInner);
 
-impl<R: AsyncBufRead> AsyncRead for ArchiveEntry<R> {
+impl AsyncRead for ArchiveEntry {
 	fn poll_read(
 		self: Pin<&mut Self>,
 		cx: &mut Context<'_>,
@@ -131,12 +131,12 @@ impl<R: AsyncBufRead> AsyncRead for ArchiveEntry<R> {
 	}
 }
 
-impl<R: AsyncBufRead + 'static> Archive<R> {
+impl Archive {
 	/// Finds the executable in the archive and returns it as an [`ArchiveEntry`]
 	pub async fn find_executable(
 		self,
 		expected_file_name: &str,
-	) -> Result<ArchiveEntry<R>, errors::FindExecutableError> {
+	) -> Result<ArchiveEntry, errors::FindExecutableError> {
 		#[derive(Debug, PartialEq, Eq)]
 		struct Candidate {
 			path: PathBuf,
@@ -188,10 +188,11 @@ impl<R: AsyncBufRead + 'static> Archive<R> {
 			ArchiveInfo(ArchiveKind::Tar, encoding) => {
 				use async_compression::tokio::bufread as decoders;
 
-				let reader = Box::pin(self.reader);
 				let reader = match encoding {
-					Some(EncodingKind::Gzip) => TarReader::Gzip(decoders::GzipDecoder::new(reader)),
+					Some(EncodingKind::Gzip) => {
-					None => TarReader::Plain(reader),
+						TarReader::Gzip(decoders::GzipDecoder::new(self.reader))
+					}
+					None => TarReader::Plain(self.reader),
 				};
 
 				let mut archive = tokio_tar::Archive::new(reader);

src/engine/source/github/mod.rs

@@ -13,7 +13,6 @@ use crate::{
 use reqwest::header::ACCEPT;
 use semver::{Version, VersionReq};
 use std::{collections::BTreeMap, path::PathBuf};
-use tokio::io::AsyncBufRead;
 
 /// The GitHub engine source
 #[derive(Debug, Eq, PartialEq, Hash, Clone)]
@@ -73,7 +72,7 @@ impl EngineSource for GitHubEngineSource {
 		&self,
 		engine_ref: &Self::Ref,
 		options: &DownloadOptions<R>,
-	) -> Result<Archive<impl AsyncBufRead + 'static>, Self::DownloadError> {
+	) -> Result<Archive, Self::DownloadError> {
 		let DownloadOptions {
 			reqwest,
 			reporter,
@@ -91,6 +90,8 @@ impl EngineSource for GitHubEngineSource {
 			.find(|asset| asset.name.eq_ignore_ascii_case(&desired_asset_name))
 			.ok_or(errors::DownloadError::AssetNotFound)?;
 
+		reporter.report_start();
+
 		let response = reqwest
 			.get(asset.url.clone())
 			.header(ACCEPT, "application/octet-stream")
@@ -100,7 +101,7 @@ impl EngineSource for GitHubEngineSource {
 
 		Ok(Archive {
 			info: asset.name.parse()?,
-			reader: response_to_async_read(response, reporter.clone()),
+			reader: Box::pin(response_to_async_read(response, reporter.clone())),
 		})
 	}
 }

src/engine/source/mod.rs

@@ -7,7 +7,6 @@ use crate::{
 };
 use semver::{Version, VersionReq};
 use std::{collections::BTreeMap, path::PathBuf};
-use tokio::io::AsyncBufRead;
 
 /// Archives
 pub mod archive;
@@ -69,7 +68,7 @@ impl EngineSource for EngineSources {
 		&self,
 		engine_ref: &Self::Ref,
 		options: &DownloadOptions<R>,
-	) -> Result<Archive<impl AsyncBufRead + 'static>, Self::DownloadError> {
+	) -> Result<Archive, Self::DownloadError> {
 		match (self, engine_ref) {
 			(EngineSources::GitHub(source), EngineRefs::GitHub(release)) => {
 				source.download(release, options).await.map_err(Into::into)

src/engine/source/traits.rs

@@ -1,7 +1,6 @@
 use crate::{engine::source::archive::Archive, reporters::DownloadProgressReporter};
 use semver::{Version, VersionReq};
 use std::{collections::BTreeMap, fmt::Debug, future::Future, path::PathBuf, sync::Arc};
-use tokio::io::AsyncBufRead;
 
 /// Options for resolving an engine
 #[derive(Debug, Clone)]
@@ -48,7 +47,5 @@ pub trait EngineSource: Debug {
 		&self,
 		engine_ref: &Self::Ref,
 		options: &DownloadOptions<R>,
-	) -> impl Future<Output = Result<Archive<impl AsyncBufRead + 'static>, Self::DownloadError>>
+	) -> impl Future<Output = Result<Archive, Self::DownloadError>> + Send + Sync;
-	       + Send
-	       + Sync;
 }

src/main.rs

@@ -299,7 +299,7 @@ async fn run() -> anyhow::Result<()> {
 		let exe_path =
 			get_or_download_engine(&reqwest, engine, req.unwrap_or(VersionReq::STAR)).await?;
 		if exe_path == current_exe {
-			break 'engines;
+			anyhow::bail!("engine linker executed by itself")
 		}
 
 		let status = std::process::Command::new(exe_path)

src/patches.rs

@@ -84,7 +84,7 @@ impl Project {
 		reporter: Arc<Reporter>,
 	) -> Result<(), errors::ApplyPatchesError>
 	where
-		Reporter: for<'a> PatchesReporter<'a> + Send + Sync + 'static,
+		Reporter: PatchesReporter + Send + Sync + 'static,
 	{
 		let manifest = self.deser_manifest().await?;
 
@@ -112,7 +112,7 @@ impl Project {
 					async move {
 						tracing::debug!("applying patch");
 
-						let progress_reporter = reporter.report_patch(&package_id.to_string());
+						let progress_reporter = reporter.report_patch(package_id.to_string());
 
 						let patch = fs::read(&patch_path)
 							.await

src/reporters.rs

@@ -15,17 +15,17 @@ use std::sync::Arc;
 use tokio::io::AsyncBufRead;
 
 /// Reports downloads.
-pub trait DownloadsReporter<'a>: Send + Sync {
+pub trait DownloadsReporter: Send + Sync {
 	/// The [`DownloadProgressReporter`] type associated with this reporter.
-	type DownloadProgressReporter: DownloadProgressReporter + 'a;
+	type DownloadProgressReporter: DownloadProgressReporter + 'static;
 
 	/// Starts a new download.
-	fn report_download<'b>(&'a self, name: &'b str) -> Self::DownloadProgressReporter;
+	fn report_download(self: Arc<Self>, name: String) -> Self::DownloadProgressReporter;
 }
 
-impl DownloadsReporter<'_> for () {
+impl DownloadsReporter for () {
 	type DownloadProgressReporter = ();
-	fn report_download(&self, name: &str) -> Self::DownloadProgressReporter {}
+	fn report_download(self: Arc<Self>, name: String) -> Self::DownloadProgressReporter {}
 }
 
 /// Reports the progress of a single download.
@@ -46,17 +46,17 @@ pub trait DownloadProgressReporter: Send + Sync {
 impl DownloadProgressReporter for () {}
 
 /// Reports the progress of applying patches.
-pub trait PatchesReporter<'a>: Send + Sync {
+pub trait PatchesReporter: Send + Sync {
 	/// The [`PatchProgressReporter`] type associated with this reporter.
-	type PatchProgressReporter: PatchProgressReporter + 'a;
+	type PatchProgressReporter: PatchProgressReporter + 'static;
 
 	/// Starts a new patch.
-	fn report_patch<'b>(&'a self, name: &'b str) -> Self::PatchProgressReporter;
+	fn report_patch(self: Arc<Self>, name: String) -> Self::PatchProgressReporter;
 }
 
-impl PatchesReporter<'_> for () {
+impl PatchesReporter for () {
 	type PatchProgressReporter = ();
-	fn report_patch(&self, name: &str) -> Self::PatchProgressReporter {}
+	fn report_patch(self: Arc<Self>, name: String) -> Self::PatchProgressReporter {}
 }
 
 /// Reports the progress of a single patch.