From 18ed8976f9834d178929e3ba332734fd2269959c Mon Sep 17 00:00:00 2001 From: "Calum H. (IMB11)" Date: Sat, 14 Nov 2026 13:08:47 +0000 Subject: [PATCH] fix(app): import instance issues --- .../app-lib/src/api/pack/import/curseforge.rs | 108 +++++++++++++----- packages/app-lib/src/api/pack/import/mmc.rs | 39 +++++-- packages/app-lib/src/api/pack/import/mod.rs | 43 ++++--- 3 files changed, 131 insertions(+), 59 deletions(-) diff --git a/packages/app-lib/src/api/pack/import/curseforge.rs b/packages/app-lib/src/api/pack/import/curseforge.rs index 6c2a54fc2af..83ea234057c 100644 --- a/packages/app-lib/src/api/pack/import/curseforge.rs +++ b/packages/app-lib/src/api/pack/import/curseforge.rs @@ -1,9 +1,10 @@ use std::path::PathBuf; +use anyhow::bail; use serde::{Deserialize, Serialize}; use crate::{ - State, + ErrorKind, State, install::{InstallPhaseDetails, InstallProgressReporter}, prelude::ModLoader, state::{AppliedContentSetPatch, EditInstance, InstanceInstallStage}, @@ -45,6 +46,36 @@ pub async fn is_valid_curseforge(instance_folder: PathBuf) -> bool { minecraft_instance.is_ok() } +fn parse_mod_loader<'a>( + name: &'a str, + game_version: &str, +) -> crate::Result<(ModLoader, &'a str)> { + let (loader, version) = name.split_once('-').unwrap_or((name, "")); + let mod_loader = match loader { + "forge" => ModLoader::Forge, + "neoforge" => ModLoader::NeoForge, + "fabric" => ModLoader::Fabric, + "quilt" => ModLoader::Quilt, + _ => bail!(ErrorKind::InputError(format!( + "unsupported CurseForge mod loader {name}" + ))), + }; + let version = version + .strip_prefix(game_version) + .and_then(|version| version.strip_prefix('-')) + .unwrap_or(version); + let version = version + .strip_suffix(game_version) + .and_then(|version| version.strip_suffix('-')) + .unwrap_or(version); + if version.is_empty() { + bail!(ErrorKind::InputError(format!( + "CurseForge mod loader {name} has no version" + ))); + } + Ok((mod_loader, version)) +} + pub async fn import_curseforge( curseforge_instance_folder: PathBuf, // instance's folder instance_id: &str, @@ -95,35 +126,16 @@ pub async fn import_curseforge( if let Some(instance_mod_loader) = minecraft_instance.base_mod_loader { let game_version = minecraft_instance.game_version; - // CF allows Forge, Fabric, and Vanilla - let mut mod_loader = None; - let mut loader_version = None; - - match instance_mod_loader.name.split('-').collect::>()[..] { - ["forge", version] => { - mod_loader = Some(ModLoader::Forge); - loader_version = Some(version.to_string()); - } - ["fabric", version, _game_version] => { - mod_loader = Some(ModLoader::Fabric); - loader_version = Some(version.to_string()); - } - _ => {} - } - - let mod_loader = mod_loader.unwrap_or(ModLoader::Vanilla); - - let loader_version = if mod_loader != ModLoader::Vanilla { - crate::launcher::get_loader_version_from_profile( - &game_version, - mod_loader, - loader_version.as_deref(), - &state.directories, - ) - .await? - } else { - None - }; + let (mod_loader, loader_version) = + parse_mod_loader(&instance_mod_loader.name, &game_version)?; + + let loader_version = crate::launcher::get_loader_version_from_profile( + &game_version, + mod_loader, + Some(loader_version), + &state.directories, + ) + .await?; crate::api::instance::edit( instance_id, @@ -185,3 +197,39 @@ pub async fn import_curseforge( Ok(()) } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parses_curseforge_mod_loader_names() { + let parse = |name, game_version| { + parse_mod_loader(name, game_version) + .map(|(loader, version)| (loader, version.to_string())) + .ok() + }; + assert_eq!( + parse("forge-47.2.0", "1.20.1"), + Some((ModLoader::Forge, "47.2.0".to_string())) + ); + assert_eq!( + parse("fabric-0.16.9-1.21.1", "1.21.1"), + Some((ModLoader::Fabric, "0.16.9".to_string())) + ); + assert_eq!( + parse("quilt-0.26.0-1.20.1", "1.20.1"), + Some((ModLoader::Quilt, "0.26.0".to_string())) + ); + assert_eq!( + parse("neoforge-21.1.72", "1.21.1"), + Some((ModLoader::NeoForge, "21.1.72".to_string())) + ); + assert_eq!( + parse("neoforge-1.20.1-47.1.106", "1.20.1"), + Some((ModLoader::NeoForge, "47.1.106".to_string())) + ); + assert_eq!(parse("liteloader-1.12.2", "1.12.2"), None); + assert_eq!(parse("forge", "1.20.1"), None); + } +} diff --git a/packages/app-lib/src/api/pack/import/mmc.rs b/packages/app-lib/src/api/pack/import/mmc.rs index 1d234fa90db..995afb3858d 100644 --- a/packages/app-lib/src/api/pack/import/mmc.rs +++ b/packages/app-lib/src/api/pack/import/mmc.rs @@ -176,17 +176,27 @@ async fn load_instance_cfg(file_path: &Path) -> crate::Result { } } +async fn find_icon(icons_dir: &Path, icon_key: &str) -> Option { + let mut dir = io::read_dir(icons_dir).await.ok()?; + while let Ok(Some(entry)) = dir.next_entry().await { + let path = entry.path(); + if path.is_file() + && path.file_stem().is_some_and(|stem| stem == icon_key) + { + return Some(path); + } + } + None +} + // #[tracing::instrument] pub async fn import_mmc( - mmc_base_path: PathBuf, // path to base mmc folder - instance_folder: String, // instance folder in mmc_base_path + mmc_base_path: PathBuf, // path to base mmc folder + mmc_instance_path: PathBuf, // path to the instance's folder instance_id: &str, reporter: InstallProgressReporter, details: InstallPhaseDetails, ) -> crate::Result<()> { - let mmc_instance_path = - mmc_base_path.join("instances").join(instance_folder); - let mmc_pack = serde_json::from_str::( &io::read_any_encoding_to_string( &mmc_instance_path.join("mmc-pack.json"), @@ -199,11 +209,20 @@ pub async fn import_mmc( load_instance_cfg(&mmc_instance_path.join("instance.cfg")).await?; // Re-cache icon - let icon = if let Some(icon_key) = instance_cfg.icon_key { - let icon_path = mmc_base_path.join("icons").join(icon_key); - import::recache_icon(icon_path).await? - } else { - None + let icon = match &instance_cfg.icon_key { + Some(icon_key) => { + match find_icon(&mmc_base_path.join("icons"), icon_key).await { + Some(icon_path) => import::recache_icon(icon_path) + .await + .inspect_err(|e| { + tracing::warn!("Could not import instance icon: {e}"); + }) + .ok() + .flatten(), + None => None, + } + } + None => None, }; // Create description from instance.cfg diff --git a/packages/app-lib/src/api/pack/import/mod.rs b/packages/app-lib/src/api/pack/import/mod.rs index 86678dec069..f7869dd7116 100644 --- a/packages/app-lib/src/api/pack/import/mod.rs +++ b/packages/app-lib/src/api/pack/import/mod.rs @@ -69,16 +69,9 @@ pub async fn get_importable_instances( "instances".to_string() } ImportLauncherType::Curseforge => "Instances".to_string(), - ImportLauncherType::MultiMC => { - mmc::get_instances_subpath(base_path.clone().join("multimc.cfg")) - .await - .unwrap_or_else(|| "instances".to_string()) + ImportLauncherType::MultiMC | ImportLauncherType::PrismLauncher => { + mmc_instances_subfolder(launcher_type, &base_path).await } - ImportLauncherType::PrismLauncher => mmc::get_instances_subpath( - base_path.clone().join("prismlauncher.cfg"), - ) - .await - .unwrap_or_else(|| "instances".to_string()), ImportLauncherType::Unknown => { let types = [ ImportLauncherType::MultiMC, @@ -124,6 +117,20 @@ pub async fn get_importable_instances( Ok(instances) } +async fn mmc_instances_subfolder( + launcher_type: ImportLauncherType, + base_path: &Path, +) -> String { + let config = if launcher_type == ImportLauncherType::MultiMC { + "multimc.cfg" + } else { + "prismlauncher.cfg" + }; + mmc::get_instances_subpath(base_path.join(config)) + .await + .unwrap_or_else(|| "instances".to_string()) +} + pub(crate) fn import_instance_with_reporter( instance_id: &str, launcher_type: ImportLauncherType, @@ -154,9 +161,12 @@ async fn import_instance_inner( }; let res = match launcher_type { ImportLauncherType::MultiMC | ImportLauncherType::PrismLauncher => { + let instance_path = base_path + .join(mmc_instances_subfolder(launcher_type, &base_path).await) + .join(instance_folder); mmc::import_mmc( - base_path, // path to base mmc folder - instance_folder, // instance folder in mmc_base_path + base_path, // path to base mmc folder + instance_path, // path to the instance's folder instance_id, reporter.clone(), details.clone(), @@ -228,14 +238,9 @@ async fn import_instance_inner( } }; - // If import failed, delete the profile - match res { - Ok(_) => {} - Err(e) => { - tracing::warn!("Import failed: {:?}", e); - let _ = crate::api::instance::remove(instance_id).await; - return Err(e); - } + if let Err(e) = res { + tracing::warn!("Import failed: {:?}", e); + return Err(e); } tracing::debug!("Completed import.");