Migrate to Turborepo (#1251)

packages/app-lib/src/api/pack/import/atlauncher.rs

@@ -0,0 +1,266 @@
+use std::{collections::HashMap, path::PathBuf};
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    pack::{
+        self,
+        import::{self, copy_dotminecraft},
+        install_from::CreatePackDescription,
+    },
+    prelude::{ModLoader, Profile, ProfilePathId},
+    state::{LinkedData, ProfileInstallStage},
+    util::io,
+    State,
+};
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ATInstance {
+    pub id: String, // minecraft version id ie: 1.12.1, not a name
+    pub launcher: ATLauncher,
+    pub java_version: ATJavaVersion,
+}
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ATLauncher {
+    pub name: String,
+    pub pack: String,
+    pub version: String, // ie: 1.6
+    pub loader_version: ATLauncherLoaderVersion,
+
+    pub modrinth_project: Option<ATLauncherModrinthProject>,
+    pub modrinth_version: Option<ATLauncherModrinthVersion>,
+    pub modrinth_manifest: Option<pack::install_from::PackFormat>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ATJavaVersion {
+    pub major_version: u8,
+    pub component: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ATLauncherLoaderVersion {
+    pub r#type: String,
+    pub version: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ATLauncherModrinthProject {
+    pub id: String,
+    pub slug: String,
+    pub project_type: String,
+    pub team: String,
+    pub client_side: Option<String>,
+    pub server_side: Option<String>,
+    pub categories: Vec<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ATLauncherModrinthVersion {
+    pub id: String,
+    pub project_id: String,
+    pub name: String,
+    pub version_number: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ATLauncherModrinthVersionFile {
+    pub hashes: HashMap<String, String>,
+    pub url: String,
+    pub filename: String,
+    pub primary: bool,
+    pub size: u64,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ATLauncherModrinthVersionDependency {
+    pub project_id: Option<String>,
+    pub version_id: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ATLauncherMod {
+    pub name: String,
+    pub version: String,
+    pub file: String,
+
+    pub modrinth_project: Option<ATLauncherModrinthProject>,
+    pub modrinth_version: Option<ATLauncherModrinthVersion>,
+}
+
+// Check if folder has a instance.json that parses
+pub async fn is_valid_atlauncher(instance_folder: PathBuf) -> bool {
+    let instance: String =
+        io::read_to_string(&instance_folder.join("instance.json"))
+            .await
+            .unwrap_or("".to_string());
+    let instance: Result<ATInstance, serde_json::Error> =
+        serde_json::from_str::<ATInstance>(&instance);
+    if let Err(e) = instance {
+        tracing::warn!(
+            "Could not parse instance.json at {}: {}",
+            instance_folder.display(),
+            e
+        );
+        false
+    } else {
+        true
+    }
+}
+
+#[tracing::instrument]
+#[theseus_macros::debug_pin]
+pub async fn import_atlauncher(
+    atlauncher_base_path: PathBuf, // path to base atlauncher folder
+    instance_folder: String,       // instance folder in atlauncher_base_path
+    profile_path: ProfilePathId,   // path to profile
+) -> crate::Result<()> {
+    let atlauncher_instance_path = atlauncher_base_path
+        .join("instances")
+        .join(instance_folder.clone());
+
+    // Load instance.json
+    let atinstance: String =
+        io::read_to_string(&atlauncher_instance_path.join("instance.json"))
+            .await?;
+    let atinstance: ATInstance =
+        serde_json::from_str::<ATInstance>(&atinstance)?;
+
+    // Icon path should be {instance_folder}/instance.png if it exists,
+    // Second possibility is ATLauncher/configs/images/{safe_pack_name}.png (safe pack name is alphanumeric lowercase)
+    let icon_path_primary = atlauncher_instance_path.join("instance.png");
+    let safe_pack_name = atinstance
+        .launcher
+        .pack
+        .replace(|c: char| !c.is_alphanumeric(), "")
+        .to_lowercase();
+    let icon_path_secondary = atlauncher_base_path
+        .join("configs")
+        .join("images")
+        .join(safe_pack_name + ".png");
+    let icon = match (icon_path_primary.exists(), icon_path_secondary.exists())
+    {
+        (true, _) => import::recache_icon(icon_path_primary).await?,
+        (_, true) => import::recache_icon(icon_path_secondary).await?,
+        _ => None,
+    };
+
+    // Create description from instance.cfg
+    let description = CreatePackDescription {
+        icon,
+        override_title: Some(atinstance.launcher.name.clone()),
+        project_id: None,
+        version_id: None,
+        existing_loading_bar: None,
+        profile_path: profile_path.clone(),
+    };
+
+    let backup_name = format!("ATLauncher-{}", instance_folder);
+    let minecraft_folder = atlauncher_instance_path;
+
+    import_atlauncher_unmanaged(
+        profile_path,
+        minecraft_folder,
+        backup_name,
+        description,
+        atinstance,
+    )
+    .await?;
+    Ok(())
+}
+
+async fn import_atlauncher_unmanaged(
+    profile_path: ProfilePathId,
+    minecraft_folder: PathBuf,
+    backup_name: String,
+    description: CreatePackDescription,
+    atinstance: ATInstance,
+) -> crate::Result<()> {
+    let mod_loader = format!(
+        "\"{}\"",
+        atinstance.launcher.loader_version.r#type.to_lowercase()
+    );
+    let mod_loader: ModLoader = serde_json::from_str::<ModLoader>(&mod_loader)
+        .map_err(|_| {
+            crate::ErrorKind::InputError(format!(
+                "Could not parse mod loader type: {}",
+                mod_loader
+            ))
+        })?;
+
+    let game_version = atinstance.id;
+
+    let loader_version = if mod_loader != ModLoader::Vanilla {
+        crate::profile::create::get_loader_version_from_loader(
+            game_version.clone(),
+            mod_loader,
+            Some(atinstance.launcher.loader_version.version.clone()),
+        )
+        .await?
+    } else {
+        None
+    };
+
+    // Set profile data to created default profile
+    crate::api::profile::edit(&profile_path, |prof| {
+        prof.metadata.name = description
+            .override_title
+            .clone()
+            .unwrap_or_else(|| backup_name.to_string());
+        prof.install_stage = ProfileInstallStage::PackInstalling;
+        prof.metadata.linked_data = Some(LinkedData {
+            project_id: description.project_id.clone(),
+            version_id: description.version_id.clone(),
+            locked: Some(
+                description.project_id.is_some()
+                    && description.version_id.is_some(),
+            ),
+        });
+        prof.metadata.icon = description.icon.clone();
+        prof.metadata.game_version = game_version.clone();
+        prof.metadata.loader_version = loader_version.clone();
+        prof.metadata.loader = mod_loader;
+
+        async { Ok(()) }
+    })
+    .await?;
+
+    // Moves .minecraft folder over (ie: overrides such as resourcepacks, mods, etc)
+    let state = State::get().await?;
+    let loading_bar = copy_dotminecraft(
+        profile_path.clone(),
+        minecraft_folder,
+        &state.io_semaphore,
+        None,
+    )
+    .await?;
+
+    if let Some(profile_val) =
+        crate::api::profile::get(&profile_path, None).await?
+    {
+        crate::launcher::install_minecraft(
+            &profile_val,
+            Some(loading_bar),
+            false,
+        )
+        .await?;
+        {
+            let state = State::get().await?;
+            let mut file_watcher = state.file_watcher.write().await;
+            Profile::watch_fs(
+                &profile_val.get_profile_full_path().await?,
+                &mut file_watcher,
+            )
+            .await?;
+        }
+        State::sync().await?;
+    }
+    Ok(())
+}

packages/app-lib/src/api/pack/import/curseforge.rs

@@ -0,0 +1,198 @@
+use std::path::PathBuf;
+
+use serde::{Deserialize, Serialize};
+
+use crate::prelude::Profile;
+use crate::state::CredentialsStore;
+use crate::{
+    prelude::{ModLoader, ProfilePathId},
+    state::ProfileInstallStage,
+    util::{
+        fetch::{fetch, write_cached_icon},
+        io,
+    },
+    State,
+};
+
+use super::{copy_dotminecraft, recache_icon};
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct MinecraftInstance {
+    pub name: Option<String>,
+    pub base_mod_loader: Option<MinecraftInstanceModLoader>,
+    pub profile_image_path: Option<PathBuf>,
+    pub installed_modpack: Option<InstalledModpack>,
+    pub game_version: String, // Minecraft game version. Non-prioritized, use this if Vanilla
+}
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct MinecraftInstanceModLoader {
+    pub name: String,
+}
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct InstalledModpack {
+    pub thumbnail_url: Option<String>,
+}
+
+// Check if folder has a minecraftinstance.json that parses
+pub async fn is_valid_curseforge(instance_folder: PathBuf) -> bool {
+    let minecraftinstance: String =
+        io::read_to_string(&instance_folder.join("minecraftinstance.json"))
+            .await
+            .unwrap_or("".to_string());
+    let minecraftinstance: Result<MinecraftInstance, serde_json::Error> =
+        serde_json::from_str::<MinecraftInstance>(&minecraftinstance);
+    minecraftinstance.is_ok()
+}
+
+pub async fn import_curseforge(
+    curseforge_instance_folder: PathBuf, // instance's folder
+    profile_path: ProfilePathId,         // path to profile
+) -> crate::Result<()> {
+    // Load minecraftinstance.json
+    let minecraft_instance: String = io::read_to_string(
+        &curseforge_instance_folder.join("minecraftinstance.json"),
+    )
+    .await?;
+    let minecraft_instance: MinecraftInstance =
+        serde_json::from_str::<MinecraftInstance>(&minecraft_instance)?;
+    let override_title: Option<String> = minecraft_instance.name.clone();
+    let backup_name = format!(
+        "Curseforge-{}",
+        curseforge_instance_folder
+            .file_name()
+            .map(|a| a.to_string_lossy().to_string())
+            .unwrap_or("Unknown".to_string())
+    );
+
+    let state = State::get().await?;
+    // Recache Curseforge Icon if it exists
+    let mut icon = None;
+
+    if let Some(icon_path) = minecraft_instance.profile_image_path.clone() {
+        icon = recache_icon(icon_path).await?;
+    } else if let Some(InstalledModpack {
+        thumbnail_url: Some(thumbnail_url),
+    }) = minecraft_instance.installed_modpack.clone()
+    {
+        let icon_bytes = fetch(
+            &thumbnail_url,
+            None,
+            &state.fetch_semaphore,
+            &CredentialsStore(None),
+        )
+        .await?;
+        let filename = thumbnail_url.rsplit('/').last();
+        if let Some(filename) = filename {
+            icon = Some(
+                write_cached_icon(
+                    filename,
+                    &state.directories.caches_dir(),
+                    icon_bytes,
+                    &state.io_semaphore,
+                )
+                .await?,
+            );
+        }
+    }
+
+    // base mod loader is always None for vanilla
+    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::<Vec<&str>>()[..] {
+            ["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::profile::create::get_loader_version_from_loader(
+                game_version.clone(),
+                mod_loader,
+                loader_version,
+            )
+            .await?
+        } else {
+            None
+        };
+
+        // Set profile data to created default profile
+        crate::api::profile::edit(&profile_path, |prof| {
+            prof.metadata.name = override_title
+                .clone()
+                .unwrap_or_else(|| backup_name.to_string());
+            prof.install_stage = ProfileInstallStage::PackInstalling;
+            prof.metadata.icon = icon.clone();
+            prof.metadata.game_version = game_version.clone();
+            prof.metadata.loader_version = loader_version.clone();
+            prof.metadata.loader = mod_loader;
+
+            async { Ok(()) }
+        })
+        .await?;
+    } else {
+        // create a vanilla profile
+        crate::api::profile::edit(&profile_path, |prof| {
+            prof.metadata.name = override_title
+                .clone()
+                .unwrap_or_else(|| backup_name.to_string());
+            prof.metadata.icon = icon.clone();
+            prof.metadata.game_version =
+                minecraft_instance.game_version.clone();
+            prof.metadata.loader_version = None;
+            prof.metadata.loader = ModLoader::Vanilla;
+
+            async { Ok(()) }
+        })
+        .await?;
+    }
+
+    // Copy in contained folders as overrides
+    let state = State::get().await?;
+    let loading_bar = copy_dotminecraft(
+        profile_path.clone(),
+        curseforge_instance_folder,
+        &state.io_semaphore,
+        None,
+    )
+    .await?;
+
+    if let Some(profile_val) =
+        crate::api::profile::get(&profile_path, None).await?
+    {
+        crate::launcher::install_minecraft(
+            &profile_val,
+            Some(loading_bar),
+            false,
+        )
+        .await?;
+
+        {
+            let state = State::get().await?;
+            let mut file_watcher = state.file_watcher.write().await;
+            Profile::watch_fs(
+                &profile_val.get_profile_full_path().await?,
+                &mut file_watcher,
+            )
+            .await?;
+        }
+        State::sync().await?;
+    }
+
+    Ok(())
+}

packages/app-lib/src/api/pack/import/gdlauncher.rs

@@ -0,0 +1,134 @@
+use std::path::PathBuf;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    prelude::{ModLoader, Profile, ProfilePathId},
+    state::ProfileInstallStage,
+    util::io,
+    State,
+};
+
+use super::{copy_dotminecraft, recache_icon};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GDLauncherConfig {
+    pub background: Option<String>,
+    pub loader: GDLauncherLoader,
+    // pub mods: Vec<GDLauncherMod>,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GDLauncherLoader {
+    pub loader_type: ModLoader,
+    pub loader_version: Option<String>,
+    pub mc_version: String,
+    pub source: Option<String>,
+    pub source_name: Option<String>,
+}
+
+// Check if folder has a config.json that parses
+pub async fn is_valid_gdlauncher(instance_folder: PathBuf) -> bool {
+    let config: String =
+        io::read_to_string(&instance_folder.join("config.json"))
+            .await
+            .unwrap_or("".to_string());
+    let config: Result<GDLauncherConfig, serde_json::Error> =
+        serde_json::from_str::<GDLauncherConfig>(&config);
+    config.is_ok()
+}
+
+pub async fn import_gdlauncher(
+    gdlauncher_instance_folder: PathBuf, // instance's folder
+    profile_path: ProfilePathId,         // path to profile
+) -> crate::Result<()> {
+    // Load config.json
+    let config: String =
+        io::read_to_string(&gdlauncher_instance_folder.join("config.json"))
+            .await?;
+    let config: GDLauncherConfig =
+        serde_json::from_str::<GDLauncherConfig>(&config)?;
+    let override_title: Option<String> = config.loader.source_name.clone();
+    let backup_name = format!(
+        "GDLauncher-{}",
+        gdlauncher_instance_folder
+            .file_name()
+            .map(|a| a.to_string_lossy().to_string())
+            .unwrap_or("Unknown".to_string())
+    );
+
+    // Re-cache icon
+    let icon = config
+        .background
+        .clone()
+        .map(|b| gdlauncher_instance_folder.join(b));
+    let icon = if let Some(icon) = icon {
+        recache_icon(icon).await?
+    } else {
+        None
+    };
+
+    let game_version = config.loader.mc_version;
+    let mod_loader = config.loader.loader_type;
+    let loader_version = config.loader.loader_version;
+
+    let loader_version = if mod_loader != ModLoader::Vanilla {
+        crate::profile::create::get_loader_version_from_loader(
+            game_version.clone(),
+            mod_loader,
+            loader_version,
+        )
+        .await?
+    } else {
+        None
+    };
+
+    // Set profile data to created default profile
+    crate::api::profile::edit(&profile_path, |prof| {
+        prof.metadata.name = override_title
+            .clone()
+            .unwrap_or_else(|| backup_name.to_string());
+        prof.install_stage = ProfileInstallStage::PackInstalling;
+        prof.metadata.icon = icon.clone();
+        prof.metadata.game_version = game_version.clone();
+        prof.metadata.loader_version = loader_version.clone();
+        prof.metadata.loader = mod_loader;
+
+        async { Ok(()) }
+    })
+    .await?;
+
+    // Copy in contained folders as overrides
+    let state = State::get().await?;
+    let loading_bar = copy_dotminecraft(
+        profile_path.clone(),
+        gdlauncher_instance_folder,
+        &state.io_semaphore,
+        None,
+    )
+    .await?;
+
+    if let Some(profile_val) =
+        crate::api::profile::get(&profile_path, None).await?
+    {
+        crate::launcher::install_minecraft(
+            &profile_val,
+            Some(loading_bar),
+            false,
+        )
+        .await?;
+        {
+            let state = State::get().await?;
+            let mut file_watcher = state.file_watcher.write().await;
+            Profile::watch_fs(
+                &profile_val.get_profile_full_path().await?,
+                &mut file_watcher,
+            )
+            .await?;
+        }
+        State::sync().await?;
+    }
+
+    Ok(())
+}

packages/app-lib/src/api/pack/import/mmc.rs

@@ -0,0 +1,344 @@
+use std::path::{Path, PathBuf};
+
+use serde::{de, Deserialize, Serialize};
+
+use crate::{
+    pack::{
+        import::{self, copy_dotminecraft},
+        install_from::{self, CreatePackDescription, PackDependency},
+    },
+    prelude::{Profile, ProfilePathId},
+    util::io,
+    State,
+};
+
+// instance.cfg
+// https://github.com/PrismLauncher/PrismLauncher/blob/develop/launcher/minecraft/MinecraftInstance.cpp
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+#[serde(untagged)]
+enum MMCInstanceEnum {
+    General(MMCInstanceGeneral),
+    Instance(MMCInstance),
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+struct MMCInstanceGeneral {
+    pub general: MMCInstance,
+}
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+pub struct MMCInstance {
+    pub java_path: Option<String>,
+    pub jvm_args: Option<String>,
+
+    #[serde(default)]
+    #[serde(deserialize_with = "deserialize_optional_bool")]
+    pub managed_pack: Option<bool>,
+
+    #[serde(rename = "ManagedPackID")]
+    pub managed_pack_id: Option<String>,
+    pub managed_pack_type: Option<MMCManagedPackType>,
+    #[serde(rename = "ManagedPackVersionID")]
+    pub managed_pack_version_id: Option<String>,
+    pub managed_pack_version_name: Option<String>,
+
+    #[serde(rename = "iconKey")]
+    pub icon_key: Option<String>,
+    #[serde(rename = "name")]
+    pub name: Option<String>,
+}
+
+// serde_ini reads 'true' and 'false' as strings, so we need to convert them to booleans
+fn deserialize_optional_bool<'de, D>(
+    deserializer: D,
+) -> Result<Option<bool>, D::Error>
+where
+    D: de::Deserializer<'de>,
+{
+    let s = Option::<String>::deserialize(deserializer)?;
+    match s {
+        Some(string) => match string.as_str() {
+            "true" => Ok(Some(true)),
+            "false" => Ok(Some(false)),
+            _ => Err(de::Error::custom("expected 'true' or 'false'")),
+        },
+        None => Ok(None),
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum MMCManagedPackType {
+    Modrinth,
+    Flame,
+    ATLauncher,
+    #[serde(other)]
+    Unknown,
+}
+
+// mmc-pack.json
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct MMCPack {
+    components: Vec<MMCComponent>,
+    format_version: u32,
+}
+
+// https://github.com/PrismLauncher/PrismLauncher/blob/develop/launcher/minecraft/Component.h
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct MMCComponent {
+    pub uid: String,
+
+    #[serde(default)]
+    pub version: Option<String>,
+    #[serde(default)]
+    pub dependency_only: bool,
+
+    #[serde(default)]
+    pub important: bool,
+    #[serde(default)]
+    pub disabled: bool,
+
+    pub cached_name: Option<String>,
+    pub cached_version: Option<String>,
+
+    #[serde(default)]
+    pub cached_requires: Vec<MMCComponentRequirement>,
+    #[serde(default)]
+    pub cached_conflicts: Vec<MMCComponentRequirement>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct MMCComponentRequirement {
+    pub uid: String,
+    pub equals_version: Option<String>,
+    pub suggests: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+#[serde(untagged)]
+enum MMCLauncherEnum {
+    General(MMCLauncherGeneral),
+    Instance(MMCLauncher),
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+struct MMCLauncherGeneral {
+    pub general: MMCLauncher,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+pub struct MMCLauncher {
+    instance_dir: String,
+}
+
+// Checks if if its a folder, and the folder contains instance.cfg and mmc-pack.json, and they both parse
+#[tracing::instrument]
+pub async fn is_valid_mmc(instance_folder: PathBuf) -> bool {
+    let instance_cfg = instance_folder.join("instance.cfg");
+    let mmc_pack = instance_folder.join("mmc-pack.json");
+
+    let mmc_pack = match io::read_to_string(&mmc_pack).await {
+        Ok(mmc_pack) => mmc_pack,
+        Err(_) => return false,
+    };
+
+    load_instance_cfg(&instance_cfg).await.is_ok()
+        && serde_json::from_str::<MMCPack>(&mmc_pack).is_ok()
+}
+
+#[tracing::instrument]
+pub async fn get_instances_subpath(config: PathBuf) -> Option<String> {
+    let launcher = io::read_to_string(&config).await.ok()?;
+    let launcher: MMCLauncherEnum = serde_ini::from_str(&launcher).ok()?;
+    match launcher {
+        MMCLauncherEnum::General(p) => Some(p.general.instance_dir),
+        MMCLauncherEnum::Instance(p) => Some(p.instance_dir),
+    }
+}
+
+// Loading the INI (instance.cfg) file
+async fn load_instance_cfg(file_path: &Path) -> crate::Result<MMCInstance> {
+    let instance_cfg: String = io::read_to_string(file_path).await?;
+    let instance_cfg_enum: MMCInstanceEnum =
+        serde_ini::from_str::<MMCInstanceEnum>(&instance_cfg)?;
+    match instance_cfg_enum {
+        MMCInstanceEnum::General(instance_cfg) => Ok(instance_cfg.general),
+        MMCInstanceEnum::Instance(instance_cfg) => Ok(instance_cfg),
+    }
+}
+
+#[tracing::instrument]
+#[theseus_macros::debug_pin]
+pub async fn import_mmc(
+    mmc_base_path: PathBuf,      // path to base mmc folder
+    instance_folder: String,     // instance folder in mmc_base_path
+    profile_path: ProfilePathId, // path to profile
+) -> crate::Result<()> {
+    let mmc_instance_path = mmc_base_path
+        .join("instances")
+        .join(instance_folder.clone());
+
+    let mmc_pack =
+        io::read_to_string(&mmc_instance_path.join("mmc-pack.json")).await?;
+    let mmc_pack: MMCPack = serde_json::from_str::<MMCPack>(&mmc_pack)?;
+
+    let instance_cfg =
+        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
+    };
+
+    // Create description from instance.cfg
+    let description = CreatePackDescription {
+        icon,
+        override_title: instance_cfg.name,
+        project_id: instance_cfg.managed_pack_id,
+        version_id: instance_cfg.managed_pack_version_id,
+        existing_loading_bar: None,
+        profile_path: profile_path.clone(),
+    };
+
+    // Managed pack
+    let backup_name = "Imported Modpack".to_string();
+
+    if instance_cfg.managed_pack.unwrap_or(false) {
+        match instance_cfg.managed_pack_type {
+            Some(MMCManagedPackType::Modrinth) => {
+                // Modrinth Managed Pack
+                // Kept separate as we may in the future want to add special handling for modrinth managed packs
+                let backup_name = "Imported Modrinth Modpack".to_string();
+                let minecraft_folder = mmc_base_path.join("instances").join(instance_folder).join(".minecraft");
+                import_mmc_unmanaged(profile_path, minecraft_folder, backup_name,  description, mmc_pack).await?;
+            }
+            Some(MMCManagedPackType::Flame) | Some(MMCManagedPackType::ATLauncher) => {
+                // For flame/atlauncher managed packs
+                // Treat as unmanaged, but with 'minecraft' folder instead of '.minecraft'
+                let minecraft_folder = mmc_base_path.join("instances").join(instance_folder).join("minecraft");
+                import_mmc_unmanaged(profile_path, minecraft_folder, backup_name,  description, mmc_pack).await?;
+            },
+            Some(_) => {
+                // For managed packs that aren't modrinth, flame, atlauncher
+                // Treat as unmanaged
+                let backup_name = "ImportedModpack".to_string();
+                let minecraft_folder = mmc_base_path.join("instances").join(instance_folder).join(".minecraft");
+                import_mmc_unmanaged(profile_path, minecraft_folder, backup_name,  description, mmc_pack).await?;
+            },
+            _ => return Err(crate::ErrorKind::InputError({
+                "Instance is managed, but managed pack type not specified in instance.cfg".to_string()
+            }).into())
+        }
+    } else {
+        // Direclty import unmanaged pack
+        let backup_name = "Imported Modpack".to_string();
+        let minecraft_folder = mmc_base_path
+            .join("instances")
+            .join(instance_folder)
+            .join(".minecraft");
+        import_mmc_unmanaged(
+            profile_path,
+            minecraft_folder,
+            backup_name,
+            description,
+            mmc_pack,
+        )
+        .await?;
+    }
+    Ok(())
+}
+
+async fn import_mmc_unmanaged(
+    profile_path: ProfilePathId,
+    minecraft_folder: PathBuf,
+    backup_name: String,
+    description: CreatePackDescription,
+    mmc_pack: MMCPack,
+) -> crate::Result<()> {
+    // Pack dependencies stored in mmc-pack.json, we convert to .mrpack pack dependencies
+    let dependencies = mmc_pack
+        .components
+        .iter()
+        .filter_map(|component| {
+            if component.uid.starts_with("net.fabricmc.fabric-loader") {
+                return Some((
+                    PackDependency::FabricLoader,
+                    component.version.clone().unwrap_or_default(),
+                ));
+            }
+            if component.uid.starts_with("net.minecraftforge") {
+                return Some((
+                    PackDependency::Forge,
+                    component.version.clone().unwrap_or_default(),
+                ));
+            }
+            if component.uid.starts_with("org.quiltmc.quilt-loader") {
+                return Some((
+                    PackDependency::QuiltLoader,
+                    component.version.clone().unwrap_or_default(),
+                ));
+            }
+            if component.uid.starts_with("net.minecraft") {
+                return Some((
+                    PackDependency::Minecraft,
+                    component.version.clone().unwrap_or_default(),
+                ));
+            }
+
+            None
+        })
+        .collect();
+
+    // Sets profile information to be that loaded from mmc-pack.json and instance.cfg
+    install_from::set_profile_information(
+        profile_path.clone(),
+        &description,
+        &backup_name,
+        &dependencies,
+        false,
+    )
+    .await?;
+
+    // Moves .minecraft folder over (ie: overrides such as resourcepacks, mods, etc)
+    let state = State::get().await?;
+    let loading_bar = copy_dotminecraft(
+        profile_path.clone(),
+        minecraft_folder,
+        &state.io_semaphore,
+        None,
+    )
+    .await?;
+
+    if let Some(profile_val) =
+        crate::api::profile::get(&profile_path, None).await?
+    {
+        crate::launcher::install_minecraft(
+            &profile_val,
+            Some(loading_bar),
+            false,
+        )
+        .await?;
+        {
+            let state = State::get().await?;
+            let mut file_watcher = state.file_watcher.write().await;
+            Profile::watch_fs(
+                &profile_val.get_profile_full_path().await?,
+                &mut file_watcher,
+            )
+            .await?;
+        }
+        State::sync().await?;
+    }
+    Ok(())
+}

packages/app-lib/src/api/pack/import/mod.rs

@@ -0,0 +1,320 @@
+use std::{
+    fmt,
+    path::{Path, PathBuf},
+};
+
+use io::IOError;
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    event::{
+        emit::{emit_loading, init_or_edit_loading},
+        LoadingBarId,
+    },
+    prelude::ProfilePathId,
+    state::Profiles,
+    util::{
+        fetch::{self, IoSemaphore},
+        io,
+    },
+};
+
+pub mod atlauncher;
+pub mod curseforge;
+pub mod gdlauncher;
+pub mod mmc;
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+pub enum ImportLauncherType {
+    MultiMC,
+    PrismLauncher,
+    ATLauncher,
+    GDLauncher,
+    Curseforge,
+    #[serde(other)]
+    Unknown,
+}
+// impl display
+impl fmt::Display for ImportLauncherType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ImportLauncherType::MultiMC => write!(f, "MultiMC"),
+            ImportLauncherType::PrismLauncher => write!(f, "PrismLauncher"),
+            ImportLauncherType::ATLauncher => write!(f, "ATLauncher"),
+            ImportLauncherType::GDLauncher => write!(f, "GDLauncher"),
+            ImportLauncherType::Curseforge => write!(f, "Curseforge"),
+            ImportLauncherType::Unknown => write!(f, "Unknown"),
+        }
+    }
+}
+
+// Return a list of importable instances from a launcher type and base path, by iterating through the folder and checking
+pub async fn get_importable_instances(
+    launcher_type: ImportLauncherType,
+    base_path: PathBuf,
+) -> crate::Result<Vec<String>> {
+    // Some launchers have a different folder structure for instances
+    let instances_subfolder = match launcher_type {
+        ImportLauncherType::GDLauncher | ImportLauncherType::ATLauncher => {
+            "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::PrismLauncher => mmc::get_instances_subpath(
+            base_path.clone().join("prismlauncher.cfg"),
+        )
+        .await
+        .unwrap_or_else(|| "instances".to_string()),
+        ImportLauncherType::Unknown => {
+            return Err(crate::ErrorKind::InputError(
+                "Launcher type Unknown".to_string(),
+            )
+            .into())
+        }
+    };
+
+    let instances_folder = base_path.join(&instances_subfolder);
+    let mut instances = Vec::new();
+    let mut dir = io::read_dir(&instances_folder).await.map_err(| _ | {
+        crate::ErrorKind::InputError(format!(
+            "Invalid {launcher_type} launcher path, could not find '{instances_subfolder}' subfolder."
+        ))
+    })?;
+    while let Some(entry) = dir
+        .next_entry()
+        .await
+        .map_err(|e| IOError::with_path(e, &instances_folder))?
+    {
+        let path = entry.path();
+        if path.is_dir() {
+            // Check instance is valid of this launcher type
+            if is_valid_importable_instance(path.clone(), launcher_type).await {
+                let name = path.file_name();
+                if let Some(name) = name {
+                    instances.push(name.to_string_lossy().to_string());
+                }
+            }
+        }
+    }
+    Ok(instances)
+}
+
+// Import an instance from a launcher type and base path
+// Note: this *deletes* the submitted empty profile
+#[theseus_macros::debug_pin]
+#[tracing::instrument]
+pub async fn import_instance(
+    profile_path: ProfilePathId, // This should be a blank profile
+    launcher_type: ImportLauncherType,
+    base_path: PathBuf,
+    instance_folder: String,
+) -> crate::Result<()> {
+    tracing::debug!("Importing instance from {instance_folder}");
+    let res = match launcher_type {
+        ImportLauncherType::MultiMC | ImportLauncherType::PrismLauncher => {
+            mmc::import_mmc(
+                base_path,            // path to base mmc folder
+                instance_folder,      // instance folder in mmc_base_path
+                profile_path.clone(), // path to profile
+            )
+            .await
+        }
+        ImportLauncherType::ATLauncher => {
+            atlauncher::import_atlauncher(
+                base_path,            // path to atlauncher folder
+                instance_folder,      // instance folder in atlauncher
+                profile_path.clone(), // path to profile
+            )
+            .await
+        }
+        ImportLauncherType::GDLauncher => {
+            gdlauncher::import_gdlauncher(
+                base_path.join("instances").join(instance_folder), // path to gdlauncher folder
+                profile_path.clone(), // path to profile
+            )
+            .await
+        }
+        ImportLauncherType::Curseforge => {
+            curseforge::import_curseforge(
+                base_path.join("Instances").join(instance_folder), // path to curseforge folder
+                profile_path.clone(), // path to profile
+            )
+            .await
+        }
+        ImportLauncherType::Unknown => {
+            return Err(crate::ErrorKind::InputError(
+                "Launcher type Unknown".to_string(),
+            )
+            .into());
+        }
+    };
+
+    // If import failed, delete the profile
+    match res {
+        Ok(_) => {}
+        Err(e) => {
+            tracing::warn!("Import failed: {:?}", e);
+            let _ = crate::api::profile::remove(&profile_path).await;
+            return Err(e);
+        }
+    }
+
+    // Check existing managed packs for potential updates
+    tokio::task::spawn(Profiles::update_modrinth_versions());
+
+    tracing::debug!("Completed import.");
+    Ok(())
+}
+
+/// Returns the default path for the given launcher type
+/// None if it can't be found or doesn't exist
+pub fn get_default_launcher_path(
+    r#type: ImportLauncherType,
+) -> Option<PathBuf> {
+    let path = match r#type {
+        ImportLauncherType::MultiMC => None, // multimc data is *in* app dir
+        ImportLauncherType::PrismLauncher => {
+            Some(dirs::data_dir()?.join("PrismLauncher"))
+        }
+        ImportLauncherType::ATLauncher => {
+            Some(dirs::data_dir()?.join("ATLauncher"))
+        }
+        ImportLauncherType::GDLauncher => {
+            Some(dirs::data_dir()?.join("gdlauncher_next"))
+        }
+        ImportLauncherType::Curseforge => {
+            Some(dirs::home_dir()?.join("curseforge").join("minecraft"))
+        }
+        ImportLauncherType::Unknown => None,
+    };
+    let path = path?;
+    if path.exists() {
+        Some(path)
+    } else {
+        None
+    }
+}
+
+/// Checks if this PathBuf is a valid instance for the given launcher type
+#[theseus_macros::debug_pin]
+#[tracing::instrument]
+pub async fn is_valid_importable_instance(
+    instance_path: PathBuf,
+    r#type: ImportLauncherType,
+) -> bool {
+    match r#type {
+        ImportLauncherType::MultiMC | ImportLauncherType::PrismLauncher => {
+            mmc::is_valid_mmc(instance_path).await
+        }
+        ImportLauncherType::ATLauncher => {
+            atlauncher::is_valid_atlauncher(instance_path).await
+        }
+        ImportLauncherType::GDLauncher => {
+            gdlauncher::is_valid_gdlauncher(instance_path).await
+        }
+        ImportLauncherType::Curseforge => {
+            curseforge::is_valid_curseforge(instance_path).await
+        }
+        ImportLauncherType::Unknown => false,
+    }
+}
+
+/// Caches an image file in the filesystem into the cache directory, and returns the path to the cached file.
+#[theseus_macros::debug_pin]
+#[tracing::instrument]
+pub async fn recache_icon(
+    icon_path: PathBuf,
+) -> crate::Result<Option<PathBuf>> {
+    let state = crate::State::get().await?;
+
+    let bytes = tokio::fs::read(&icon_path).await;
+    if let Ok(bytes) = bytes {
+        let bytes = bytes::Bytes::from(bytes);
+        let cache_dir = &state.directories.caches_dir();
+        let semaphore = &state.io_semaphore;
+        Ok(Some(
+            fetch::write_cached_icon(
+                &icon_path.to_string_lossy(),
+                cache_dir,
+                bytes,
+                semaphore,
+            )
+            .await?,
+        ))
+    } else {
+        // could not find icon (for instance, prism default icon, etc)
+        Ok(None)
+    }
+}
+
+pub async fn copy_dotminecraft(
+    profile_path_id: ProfilePathId,
+    dotminecraft: PathBuf,
+    io_semaphore: &IoSemaphore,
+    existing_loading_bar: Option<LoadingBarId>,
+) -> crate::Result<LoadingBarId> {
+    // Get full path to profile
+    let profile_path = profile_path_id.get_full_path().await?;
+
+    // Gets all subfiles recursively in src
+    let subfiles = get_all_subfiles(&dotminecraft).await?;
+    let total_subfiles = subfiles.len() as u64;
+
+    let loading_bar = init_or_edit_loading(
+        existing_loading_bar,
+        crate::LoadingBarType::CopyProfile {
+            import_location: dotminecraft.clone(),
+            profile_name: profile_path_id.to_string(),
+        },
+        total_subfiles as f64,
+        "Copying files in profile",
+    )
+    .await?;
+
+    // Copy each file
+    for src_child in subfiles {
+        let dst_child =
+            src_child.strip_prefix(&dotminecraft).map_err(|_| {
+                crate::ErrorKind::InputError(format!(
+                    "Invalid file: {}",
+                    &src_child.display()
+                ))
+            })?;
+        let dst_child = profile_path.join(dst_child);
+
+        // sleep for cpu for 1 millisecond
+        tokio::time::sleep(std::time::Duration::from_millis(1)).await;
+
+        fetch::copy(&src_child, &dst_child, io_semaphore).await?;
+
+        emit_loading(&loading_bar, 1.0, None).await?;
+    }
+    Ok(loading_bar)
+}
+
+/// Recursively get a list of all subfiles in src
+/// uses async recursion
+#[theseus_macros::debug_pin]
+#[async_recursion::async_recursion]
+#[tracing::instrument]
+pub async fn get_all_subfiles(src: &Path) -> crate::Result<Vec<PathBuf>> {
+    if !src.is_dir() {
+        return Ok(vec![src.to_path_buf()]);
+    }
+
+    let mut files = Vec::new();
+    let mut dir = io::read_dir(&src).await?;
+    while let Some(child) = dir
+        .next_entry()
+        .await
+        .map_err(|e| IOError::with_path(e, src))?
+    {
+        let src_child = child.path();
+        files.append(&mut get_all_subfiles(&src_child).await?);
+    }
+    Ok(files)
+}

packages/app-lib/src/api/pack/install_from.rs

@@ -0,0 +1,419 @@
+use crate::config::MODRINTH_API_URL;
+use crate::data::ModLoader;
+use crate::event::emit::{emit_loading, init_loading};
+use crate::event::{LoadingBarId, LoadingBarType};
+use crate::prelude::ProfilePathId;
+use crate::state::{
+    LinkedData, ModrinthProject, ModrinthVersion, ProfileInstallStage, SideType,
+};
+use crate::util::fetch::{
+    fetch, fetch_advanced, fetch_json, write_cached_icon,
+};
+use crate::util::io;
+use crate::{InnerProjectPathUnix, State};
+
+use reqwest::Method;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+use std::path::PathBuf;
+
+#[derive(Serialize, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct PackFormat {
+    pub game: String,
+    pub format_version: i32,
+    pub version_id: String,
+    pub name: String,
+    pub summary: Option<String>,
+    pub files: Vec<PackFile>,
+    pub dependencies: HashMap<PackDependency, String>,
+}
+
+#[derive(Serialize, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct PackFile {
+    pub path: InnerProjectPathUnix,
+    pub hashes: HashMap<PackFileHash, String>,
+    pub env: Option<HashMap<EnvType, SideType>>,
+    pub downloads: Vec<String>,
+    pub file_size: u32,
+}
+
+#[derive(Serialize, Deserialize, Eq, PartialEq, Hash)]
+#[serde(rename_all = "camelCase", from = "String")]
+pub enum PackFileHash {
+    Sha1,
+    Sha512,
+    Unknown(String),
+}
+
+impl From<String> for PackFileHash {
+    fn from(s: String) -> Self {
+        return match s.as_str() {
+            "sha1" => PackFileHash::Sha1,
+            "sha512" => PackFileHash::Sha512,
+            _ => PackFileHash::Unknown(s),
+        };
+    }
+}
+
+#[derive(Serialize, Deserialize, Eq, PartialEq, Hash)]
+#[serde(rename_all = "camelCase")]
+pub enum EnvType {
+    Client,
+    Server,
+}
+
+#[derive(Serialize, Deserialize, Clone, Copy, Hash, PartialEq, Eq, Debug)]
+pub enum PackDependency {
+    #[serde(rename = "forge")]
+    Forge,
+
+    #[serde(rename = "neoforge")]
+    #[serde(alias = "neo-forge")]
+    NeoForge,
+
+    #[serde(rename = "fabric-loader")]
+    FabricLoader,
+
+    #[serde(rename = "quilt-loader")]
+    QuiltLoader,
+
+    #[serde(rename = "minecraft")]
+    Minecraft,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase", tag = "type")]
+pub enum CreatePackLocation {
+    // Create a pack from a modrinth version ID (such as a modpack)
+    FromVersionId {
+        project_id: String,
+        version_id: String,
+        title: String,
+        icon_url: Option<String>,
+    },
+    // Create a pack from a file (such as an .mrpack for installing from a file, or a folder name for importing)
+    FromFile {
+        path: PathBuf,
+    },
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreatePackProfile {
+    pub name: String, // the name of the profile, and relative path
+    pub game_version: String, // the game version of the profile
+    pub modloader: ModLoader, // the modloader to use
+    pub loader_version: Option<String>, // the modloader version to use, set to "latest", "stable", or the ID of your chosen loader. defaults to latest
+    pub icon: Option<PathBuf>,          // the icon for the profile
+    pub icon_url: Option<String>, // the URL icon for a profile (ONLY USED FOR TEMPORARY PROFILES)
+    pub linked_data: Option<LinkedData>, // the linked project ID (mainly for modpacks)- used for updating
+    pub skip_install_profile: Option<bool>,
+    pub no_watch: Option<bool>,
+}
+
+// default
+impl Default for CreatePackProfile {
+    fn default() -> Self {
+        CreatePackProfile {
+            name: "Untitled".to_string(),
+            game_version: "1.19.4".to_string(),
+            modloader: ModLoader::Vanilla,
+            loader_version: None,
+            icon: None,
+            icon_url: None,
+            linked_data: None,
+            skip_install_profile: Some(true),
+            no_watch: Some(false),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct CreatePack {
+    pub file: bytes::Bytes,
+    pub description: CreatePackDescription,
+}
+
+#[derive(Clone, Debug)]
+pub struct CreatePackDescription {
+    pub icon: Option<PathBuf>,
+    pub override_title: Option<String>,
+    pub project_id: Option<String>,
+    pub version_id: Option<String>,
+    pub existing_loading_bar: Option<LoadingBarId>,
+    pub profile_path: ProfilePathId,
+}
+
+pub fn get_profile_from_pack(
+    location: CreatePackLocation,
+) -> CreatePackProfile {
+    match location {
+        CreatePackLocation::FromVersionId {
+            project_id,
+            version_id,
+            title,
+            icon_url,
+        } => CreatePackProfile {
+            name: title,
+            icon_url,
+            linked_data: Some(LinkedData {
+                project_id: Some(project_id),
+                version_id: Some(version_id),
+                locked: Some(true),
+            }),
+            ..Default::default()
+        },
+        CreatePackLocation::FromFile { path } => {
+            let file_name = path
+                .file_stem()
+                .unwrap_or_default()
+                .to_string_lossy()
+                .to_string();
+
+            CreatePackProfile {
+                name: file_name,
+                ..Default::default()
+            }
+        }
+    }
+}
+
+#[tracing::instrument]
+#[theseus_macros::debug_pin]
+pub async fn generate_pack_from_version_id(
+    project_id: String,
+    version_id: String,
+    title: String,
+    icon_url: Option<String>,
+    profile_path: ProfilePathId,
+
+    // Existing loading bar. Unlike when existing_loading_bar is used, this one is pre-initialized with PackFileDownload
+    // For example, you might use this if multiple packs are being downloaded at once and you want to use the same loading bar
+    initialized_loading_bar: Option<LoadingBarId>,
+) -> crate::Result<CreatePack> {
+    let state = State::get().await?;
+
+    let loading_bar = if let Some(bar) = initialized_loading_bar {
+        emit_loading(&bar, 0.0, Some("Downloading pack file")).await?;
+        bar
+    } else {
+        init_loading(
+            LoadingBarType::PackFileDownload {
+                profile_path: profile_path.get_full_path().await?,
+                pack_name: title,
+                icon: icon_url,
+                pack_version: version_id.clone(),
+            },
+            100.0,
+            "Downloading pack file",
+        )
+        .await?
+    };
+
+    emit_loading(&loading_bar, 0.0, Some("Fetching version")).await?;
+    let creds = state.credentials.read().await;
+    let version: ModrinthVersion = fetch_json(
+        Method::GET,
+        &format!("{}version/{}", MODRINTH_API_URL, version_id),
+        None,
+        None,
+        &state.fetch_semaphore,
+        &creds,
+    )
+    .await?;
+    emit_loading(&loading_bar, 10.0, None).await?;
+
+    let (url, hash) =
+        if let Some(file) = version.files.iter().find(|x| x.primary) {
+            Some((file.url.clone(), file.hashes.get("sha1")))
+        } else {
+            version
+                .files
+                .first()
+                .map(|file| (file.url.clone(), file.hashes.get("sha1")))
+        }
+        .ok_or_else(|| {
+            crate::ErrorKind::InputError(
+                "Specified version has no files".to_string(),
+            )
+        })?;
+
+    let file = fetch_advanced(
+        Method::GET,
+        &url,
+        hash.map(|x| &**x),
+        None,
+        None,
+        Some((&loading_bar, 70.0)),
+        &state.fetch_semaphore,
+        &creds,
+    )
+    .await?;
+    emit_loading(&loading_bar, 0.0, Some("Fetching project metadata")).await?;
+
+    let project: ModrinthProject = fetch_json(
+        Method::GET,
+        &format!("{}project/{}", MODRINTH_API_URL, version.project_id),
+        None,
+        None,
+        &state.fetch_semaphore,
+        &creds,
+    )
+    .await?;
+
+    emit_loading(&loading_bar, 10.0, Some("Retrieving icon")).await?;
+    let icon = if let Some(icon_url) = project.icon_url {
+        let state = State::get().await?;
+        let icon_bytes =
+            fetch(&icon_url, None, &state.fetch_semaphore, &creds).await?;
+        drop(creds);
+
+        let filename = icon_url.rsplit('/').next();
+
+        if let Some(filename) = filename {
+            Some(
+                write_cached_icon(
+                    filename,
+                    &state.directories.caches_dir(),
+                    icon_bytes,
+                    &state.io_semaphore,
+                )
+                .await?,
+            )
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+    emit_loading(&loading_bar, 10.0, None).await?;
+
+    Ok(CreatePack {
+        file,
+        description: CreatePackDescription {
+            icon,
+            override_title: None,
+            project_id: Some(project_id),
+            version_id: Some(version_id),
+            existing_loading_bar: Some(loading_bar),
+            profile_path,
+        },
+    })
+}
+
+#[tracing::instrument]
+#[theseus_macros::debug_pin]
+pub async fn generate_pack_from_file(
+    path: PathBuf,
+    profile_path: ProfilePathId,
+) -> crate::Result<CreatePack> {
+    let file = io::read(&path).await?;
+    Ok(CreatePack {
+        file: bytes::Bytes::from(file),
+        description: CreatePackDescription {
+            icon: None,
+            override_title: None,
+            project_id: None,
+            version_id: None,
+            existing_loading_bar: None,
+            profile_path,
+        },
+    })
+}
+
+/// Sets generated profile attributes to the pack ones (using profile::edit)
+/// This includes the pack name, icon, game version, loader version, and loader
+#[theseus_macros::debug_pin]
+pub async fn set_profile_information(
+    profile_path: ProfilePathId,
+    description: &CreatePackDescription,
+    backup_name: &str,
+    dependencies: &HashMap<PackDependency, String>,
+    ignore_lock: bool, // do not change locked status
+) -> crate::Result<()> {
+    let mut game_version: Option<&String> = None;
+    let mut mod_loader = None;
+    let mut loader_version = None;
+
+    for (key, value) in dependencies {
+        match key {
+            PackDependency::Forge => {
+                mod_loader = Some(ModLoader::Forge);
+                loader_version = Some(value);
+            }
+            PackDependency::NeoForge => {
+                mod_loader = Some(ModLoader::NeoForge);
+                loader_version = Some(value);
+            }
+            PackDependency::FabricLoader => {
+                mod_loader = Some(ModLoader::Fabric);
+                loader_version = Some(value);
+            }
+            PackDependency::QuiltLoader => {
+                mod_loader = Some(ModLoader::Quilt);
+                loader_version = Some(value);
+            }
+            PackDependency::Minecraft => game_version = Some(value),
+        }
+    }
+
+    let game_version = if let Some(game_version) = game_version {
+        game_version
+    } else {
+        return Err(crate::ErrorKind::InputError(
+            "Pack did not specify Minecraft version".to_string(),
+        )
+        .into());
+    };
+
+    let mod_loader = mod_loader.unwrap_or(ModLoader::Vanilla);
+    let loader_version = if mod_loader != ModLoader::Vanilla {
+        crate::profile::create::get_loader_version_from_loader(
+            game_version.clone(),
+            mod_loader,
+            loader_version.cloned(),
+        )
+        .await?
+    } else {
+        None
+    };
+    // Sets values in profile
+    crate::api::profile::edit(&profile_path, |prof| {
+        prof.metadata.name = description
+            .override_title
+            .clone()
+            .unwrap_or_else(|| backup_name.to_string());
+        prof.install_stage = ProfileInstallStage::PackInstalling;
+
+        let project_id = description.project_id.clone();
+        let version_id = description.version_id.clone();
+
+        prof.metadata.linked_data = if project_id.is_some()
+            && version_id.is_some()
+        {
+            Some(LinkedData {
+                project_id,
+                version_id,
+                locked: if !ignore_lock {
+                    Some(true)
+                } else {
+                    prof.metadata.linked_data.as_ref().and_then(|x| x.locked)
+                },
+            })
+        } else {
+            None
+        };
+
+        prof.metadata.icon = description.icon.clone();
+        prof.metadata.game_version = game_version.clone();
+        prof.metadata.loader_version = loader_version.clone();
+        prof.metadata.loader = mod_loader;
+
+        async { Ok(()) }
+    })
+    .await?;
+    Ok(())
+}

packages/app-lib/src/api/pack/install_mrpack.rs

@@ -0,0 +1,430 @@
+use crate::config::MODRINTH_API_URL;
+use crate::event::emit::{
+    emit_loading, init_or_edit_loading, loading_try_for_each_concurrent,
+};
+use crate::event::LoadingBarType;
+use crate::pack::install_from::{
+    set_profile_information, EnvType, PackFile, PackFileHash,
+};
+use crate::prelude::{ModrinthVersion, ProfilePathId, ProjectMetadata};
+use crate::state::{ProfileInstallStage, Profiles, SideType};
+use crate::util::fetch::{fetch_json, fetch_mirrors, write};
+use crate::util::io;
+use crate::{profile, State};
+use async_zip::base::read::seek::ZipFileReader;
+use reqwest::Method;
+use serde_json::json;
+
+use std::collections::HashMap;
+use std::io::Cursor;
+use std::path::{Component, PathBuf};
+
+use super::install_from::{
+    generate_pack_from_file, generate_pack_from_version_id, CreatePack,
+    CreatePackLocation, PackFormat,
+};
+
+/// Install a pack
+/// Wrapper around install_pack_files that generates a pack creation description, and
+/// attempts to install the pack files. If it fails, it will remove the profile (fail safely)
+/// Install a modpack from a mrpack file (a modrinth .zip format)
+#[theseus_macros::debug_pin]
+pub async fn install_zipped_mrpack(
+    location: CreatePackLocation,
+    profile_path: ProfilePathId,
+) -> crate::Result<ProfilePathId> {
+    // Get file from description
+    let create_pack: CreatePack = match location {
+        CreatePackLocation::FromVersionId {
+            project_id,
+            version_id,
+            title,
+            icon_url,
+        } => {
+            generate_pack_from_version_id(
+                project_id,
+                version_id,
+                title,
+                icon_url,
+                profile_path.clone(),
+                None,
+            )
+            .await?
+        }
+        CreatePackLocation::FromFile { path } => {
+            generate_pack_from_file(path, profile_path.clone()).await?
+        }
+    };
+
+    // Install pack files, and if it fails, fail safely by removing the profile
+    let result = install_zipped_mrpack_files(create_pack, false).await;
+
+    // Check existing managed packs for potential updates
+    tokio::task::spawn(Profiles::update_modrinth_versions());
+
+    match result {
+        Ok(profile) => Ok(profile),
+        Err(err) => {
+            let _ = crate::api::profile::remove(&profile_path).await;
+
+            Err(err)
+        }
+    }
+}
+
+/// Install all pack files from a description
+/// Does not remove the profile if it fails
+#[theseus_macros::debug_pin]
+pub async fn install_zipped_mrpack_files(
+    create_pack: CreatePack,
+    ignore_lock: bool,
+) -> crate::Result<ProfilePathId> {
+    let state = &State::get().await?;
+
+    let file = create_pack.file;
+    let description = create_pack.description.clone(); // make a copy for profile edit function
+    let icon = create_pack.description.icon;
+    let project_id = create_pack.description.project_id;
+    let version_id = create_pack.description.version_id;
+    let existing_loading_bar = create_pack.description.existing_loading_bar;
+    let profile_path = create_pack.description.profile_path;
+    let icon_exists = icon.is_some();
+
+    let reader: Cursor<&bytes::Bytes> = Cursor::new(&file);
+
+    // Create zip reader around file
+    let mut zip_reader =
+        ZipFileReader::with_tokio(reader).await.map_err(|_| {
+            crate::Error::from(crate::ErrorKind::InputError(
+                "Failed to read input modpack zip".to_string(),
+            ))
+        })?;
+
+    // Extract index of modrinth.index.json
+    let zip_index_option = zip_reader.file().entries().iter().position(|f| {
+        f.filename().as_str().unwrap_or_default() == "modrinth.index.json"
+    });
+    if let Some(zip_index) = zip_index_option {
+        let mut manifest = String::new();
+        let mut reader = zip_reader.reader_with_entry(zip_index).await?;
+        reader.read_to_string_checked(&mut manifest).await?;
+
+        let pack: PackFormat = serde_json::from_str(&manifest)?;
+
+        if &*pack.game != "minecraft" {
+            return Err(crate::ErrorKind::InputError(
+                "Pack does not support Minecraft".to_string(),
+            )
+            .into());
+        }
+
+        // Sets generated profile attributes to the pack ones (using profile::edit)
+        set_profile_information(
+            profile_path.clone(),
+            &description,
+            &pack.name,
+            &pack.dependencies,
+            ignore_lock,
+        )
+        .await?;
+
+        let profile_path = profile_path.clone();
+        let loading_bar = init_or_edit_loading(
+            existing_loading_bar,
+            LoadingBarType::PackDownload {
+                profile_path: profile_path.get_full_path().await?.clone(),
+                pack_name: pack.name.clone(),
+                icon,
+                pack_id: project_id,
+                pack_version: version_id,
+            },
+            100.0,
+            "Downloading modpack",
+        )
+        .await?;
+
+        let num_files = pack.files.len();
+        use futures::StreamExt;
+        loading_try_for_each_concurrent(
+            futures::stream::iter(pack.files.into_iter())
+                .map(Ok::<PackFile, crate::Error>),
+            None,
+            Some(&loading_bar),
+            70.0,
+            num_files,
+            None,
+            |project| {
+                let profile_path = profile_path.clone();
+                async move {
+                    //TODO: Future update: prompt user for optional files in a modpack
+                    if let Some(env) = project.env {
+                        if env
+                            .get(&EnvType::Client)
+                            .map(|x| x == &SideType::Unsupported)
+                            .unwrap_or(false)
+                        {
+                            return Ok(());
+                        }
+                    }
+
+                    let creds = state.credentials.read().await;
+                    let file = fetch_mirrors(
+                        &project
+                            .downloads
+                            .iter()
+                            .map(|x| &**x)
+                            .collect::<Vec<&str>>(),
+                        project.hashes.get(&PackFileHash::Sha1).map(|x| &**x),
+                        &state.fetch_semaphore,
+                        &creds,
+                    )
+                    .await?;
+                    drop(creds);
+
+                    let project_path = project.path.to_string();
+
+                    let path =
+                        std::path::Path::new(&project_path).components().next();
+                    if let Some(path) = path {
+                        match path {
+                            Component::CurDir | Component::Normal(_) => {
+                                let path = profile_path
+                                    .get_full_path()
+                                    .await?
+                                    .join(&project_path);
+                                write(&path, &file, &state.io_semaphore)
+                                    .await?;
+                            }
+                            _ => {}
+                        };
+                    }
+                    Ok(())
+                }
+            },
+        )
+        .await?;
+
+        emit_loading(&loading_bar, 0.0, Some("Extracting overrides")).await?;
+
+        let mut total_len = 0;
+
+        for index in 0..zip_reader.file().entries().len() {
+            let file = zip_reader.file().entries().get(index).unwrap();
+            let filename = file.filename().as_str().unwrap_or_default();
+
+            if (filename.starts_with("overrides")
+                || filename.starts_with("client-overrides"))
+                && !filename.ends_with('/')
+            {
+                total_len += 1;
+            }
+        }
+
+        for index in 0..zip_reader.file().entries().len() {
+            let file = zip_reader.file().entries().get(index).unwrap();
+
+            let filename = file.filename().as_str().unwrap_or_default();
+
+            let file_path = PathBuf::from(filename);
+            if (filename.starts_with("overrides")
+                || filename.starts_with("client-overrides"))
+                && !filename.ends_with('/')
+            {
+                // Reads the file into the 'content' variable
+                let mut content = Vec::new();
+                let mut reader = zip_reader.reader_with_entry(index).await?;
+                reader.read_to_end_checked(&mut content).await?;
+
+                let mut new_path = PathBuf::new();
+                let components = file_path.components().skip(1);
+
+                for component in components {
+                    new_path.push(component);
+                }
+
+                if new_path.file_name().is_some() {
+                    write(
+                        &profile_path.get_full_path().await?.join(new_path),
+                        &content,
+                        &state.io_semaphore,
+                    )
+                    .await?;
+                }
+
+                emit_loading(
+                    &loading_bar,
+                    30.0 / total_len as f64,
+                    Some(&format!(
+                        "Extracting override {}/{}",
+                        index, total_len
+                    )),
+                )
+                .await?;
+            }
+        }
+
+        // If the icon doesn't exist, we expect icon.png to be a potential icon.
+        // If it doesn't exist, and an override to icon.png exists, cache and use that
+        let potential_icon =
+            profile_path.get_full_path().await?.join("icon.png");
+        if !icon_exists && potential_icon.exists() {
+            profile::edit_icon(&profile_path, Some(&potential_icon)).await?;
+        }
+
+        if let Some(profile_val) = profile::get(&profile_path, None).await? {
+            crate::launcher::install_minecraft(
+                &profile_val,
+                Some(loading_bar),
+                false,
+            )
+            .await?;
+
+            State::sync().await?;
+        }
+
+        Ok::<ProfilePathId, crate::Error>(profile_path.clone())
+    } else {
+        Err(crate::Error::from(crate::ErrorKind::InputError(
+            "No pack manifest found in mrpack".to_string(),
+        )))
+    }
+}
+
+#[tracing::instrument(skip(mrpack_file))]
+#[theseus_macros::debug_pin]
+pub async fn remove_all_related_files(
+    profile_path: ProfilePathId,
+    mrpack_file: bytes::Bytes,
+) -> crate::Result<()> {
+    let reader: Cursor<&bytes::Bytes> = Cursor::new(&mrpack_file);
+
+    // Create zip reader around file
+    let mut zip_reader =
+        ZipFileReader::with_tokio(reader).await.map_err(|_| {
+            crate::Error::from(crate::ErrorKind::InputError(
+                "Failed to read input modpack zip".to_string(),
+            ))
+        })?;
+
+    // Extract index of modrinth.index.json
+    let zip_index_option = zip_reader.file().entries().iter().position(|f| {
+        f.filename().as_str().unwrap_or_default() == "modrinth.index.json"
+    });
+    if let Some(zip_index) = zip_index_option {
+        let mut manifest = String::new();
+
+        let mut reader = zip_reader.reader_with_entry(zip_index).await?;
+        reader.read_to_string_checked(&mut manifest).await?;
+
+        let pack: PackFormat = serde_json::from_str(&manifest)?;
+
+        if &*pack.game != "minecraft" {
+            return Err(crate::ErrorKind::InputError(
+                "Pack does not support Minecraft".to_string(),
+            )
+            .into());
+        }
+
+        // Set install stage to installing, and do not change it back (as files are being removed and are not being reinstalled here)
+        crate::api::profile::edit(&profile_path, |prof| {
+            prof.install_stage = ProfileInstallStage::PackInstalling;
+            async { Ok(()) }
+        })
+        .await?;
+
+        // First, remove all modrinth projects by their version hashes
+        // Remove all modrinth projects by their version hashes
+        // We need to do a fetch to get the project ids from Modrinth
+        let state = State::get().await?;
+        let all_hashes = pack
+            .files
+            .iter()
+            .filter_map(|f| Some(f.hashes.get(&PackFileHash::Sha512)?.clone()))
+            .collect::<Vec<_>>();
+        let creds = state.credentials.read().await;
+
+        // First, get project info by hash
+        let files_url = format!("{}version_files", MODRINTH_API_URL);
+
+        let hash_projects = fetch_json::<HashMap<String, ModrinthVersion>>(
+            Method::POST,
+            &files_url,
+            None,
+            Some(json!({
+                "hashes": all_hashes,
+                "algorithm": "sha512",
+            })),
+            &state.fetch_semaphore,
+            &creds,
+        )
+        .await?;
+        let to_remove = hash_projects
+            .into_values()
+            .map(|p| p.project_id)
+            .collect::<Vec<_>>();
+        let profile =
+            profile::get(&profile_path, None).await?.ok_or_else(|| {
+                crate::ErrorKind::UnmanagedProfileError(
+                    profile_path.to_string(),
+                )
+            })?;
+        for (project_id, project) in &profile.projects {
+            if let ProjectMetadata::Modrinth { project, .. } = &project.metadata
+            {
+                if to_remove.contains(&project.id) {
+                    let path = profile
+                        .get_profile_full_path()
+                        .await?
+                        .join(project_id.0.clone());
+                    if path.exists() {
+                        io::remove_file(&path).await?;
+                    }
+                }
+            }
+        }
+
+        // Iterate over all Modrinth project file paths in the json, and remove them
+        // (There should be few, but this removes any files the .mrpack intended as Modrinth projects but were unrecognized)
+        for file in pack.files {
+            let path: PathBuf = profile_path
+                .get_full_path()
+                .await?
+                .join(file.path.to_string());
+            if path.exists() {
+                io::remove_file(&path).await?;
+            }
+        }
+
+        // Iterate over each 'overrides' file and remove it
+        for index in 0..zip_reader.file().entries().len() {
+            let file = zip_reader.file().entries().get(index).unwrap();
+
+            let filename = file.filename().as_str().unwrap_or_default();
+
+            let file_path = PathBuf::from(filename);
+            if (filename.starts_with("overrides")
+                || filename.starts_with("client-overrides"))
+                && !filename.ends_with('/')
+            {
+                let mut new_path = PathBuf::new();
+                let components = file_path.components().skip(1);
+
+                for component in components {
+                    new_path.push(component);
+                }
+
+                // Remove this file if a corresponding one exists in the filesystem
+                let existing_file =
+                    profile_path.get_full_path().await?.join(&new_path);
+                if existing_file.exists() {
+                    io::remove_file(&existing_file).await?;
+                }
+            }
+        }
+        Ok(())
+    } else {
+        Err(crate::Error::from(crate::ErrorKind::InputError(
+            "No pack manifest found in mrpack".to_string(),
+        )))
+    }
+}

packages/app-lib/src/api/pack/mod.rs

@@ -0,0 +1,3 @@
+pub mod import;
+pub mod install_from;
+pub mod install_mrpack;