Move files in preparation for monorepo migration

libs/theseus/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(())
+}

libs/theseus/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(())
+}

libs/theseus/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(())
+}

libs/theseus/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(())
+}

libs/theseus/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)
+}