Support importing from arbitrary paths

Author: Moulberry

crates/backend/src/backend_handler.rs

@@ -1055,8 +1055,8 @@ impl BackendState {
                     }
                 }
             },
-            MessageToBackend::GetImportFromOtherLauncherPaths { channel } => {
-                let result = crate::launcher_import::discover_instances_from_other_launchers();
+            MessageToBackend::GetImportFromOtherLauncherJob { channel, launcher, path } => {
+                let result = crate::launcher_import::get_import_from_other_launcher_job(launcher, path);
                 _ = channel.send(result);
             },
             MessageToBackend::GetSyncState { channel } => {
@@ -1491,8 +1491,8 @@ impl BackendState {
             MessageToBackend::InstallUpdate { update, modal_action } => {
                 tokio::task::spawn(crate::update::install_update(self.redirecting_http_client.clone(), self.directories.clone(), self.send.clone(), update, modal_action));
             },
-            MessageToBackend::ImportFromOtherLauncher { launcher, import_accounts, import_instances, modal_action } => {
-                crate::launcher_import::import_from_other_launcher(self, launcher, import_accounts, import_instances, modal_action).await;
+            MessageToBackend::ImportFromOtherLauncher { launcher, import_job, modal_action } => {
+                crate::launcher_import::import_from_other_launcher(self, launcher, import_job, modal_action).await;
             },
             MessageToBackend::GetAccountSkin { account, result } => {
                 let backend = self.clone();

crates/backend/src/launcher_import/atlauncher.rs

@@ -1,6 +1,6 @@
-use std::{path::{Path, PathBuf}, str::FromStr};
+use std::{path::{Path, PathBuf}, str::FromStr, sync::Arc};
 use auth::{credentials::AccountCredentials, models::{TokenWithExpiry, XstsToken}, secret::PlatformSecretStorage};
-use bridge::modal_action::{ModalAction, ProgressTracker};
+use bridge::{import::ImportFromOtherLauncherJob, modal_action::{ModalAction, ProgressTracker}};
 use chrono::DateTime;
 use log::debug;
 use schema::{instance::{InstanceConfiguration, InstanceMemoryConfiguration,  InstanceWrapperCommandConfiguration}, loader::Loader};
@@ -230,52 +230,45 @@ struct AtLauncherXstsAuth {
     display_claims: AtLauncherDisplayClaims,
 }
 
-
 #[derive(Debug, Deserialize)]
 // #[serde(rename_all = "case")]
 struct AtLauncherDisplayClaims {
     xui: Vec<AtLauncherDisplayClaim>,
 }
 
-
 #[derive(Debug, Deserialize)]
 // #[serde(rename_all = "case")]
 struct AtLauncherDisplayClaim {
     uhs: String,
 }
 
-
-
-
-pub async fn import_from_atlauncher(backend: &BackendState, path: &Path, import_accounts: bool, import_instance: bool, modal_action: ModalAction) {
-    let Ok(launcher_config_bytes) = std::fs::read(path.join("configs/ATLauncher.json")) else {
+pub async fn import_from_atlauncher(backend: &BackendState, import_job: ImportFromOtherLauncherJob, modal_action: ModalAction) {
+    let Ok(launcher_config_bytes) = std::fs::read(import_job.root.join("configs/ATLauncher.json")) else {
         return;
     };
     let launcher_config = serde_json::from_slice::<AtLauncherConfig>(&launcher_config_bytes).expect("Failed to parse to json");
-    // log::debug!("Launcher config: {}", launcher_config.is_some());
 
-    if import_accounts {
-        import_accounts_from_atlauncher(backend, path, &launcher_config, &modal_action).await;
-    }
-    if import_instance {
-        import_instances_from_atlauncher(backend, path, &launcher_config, &modal_action);
-    }
+    import_accounts_from_atlauncher(backend, &import_job, &launcher_config, &modal_action).await;
+    import_instances_from_atlauncher(backend, &import_job, &launcher_config, &modal_action);
 }
 
-async fn import_accounts_from_atlauncher(backend: &BackendState, path: &Path, launcher_config: &AtLauncherConfig, modal_action: &ModalAction) {
+async fn import_accounts_from_atlauncher(backend: &BackendState, import_job: &ImportFromOtherLauncherJob, launcher_config: &AtLauncherConfig, modal_action: &ModalAction) {
+    if !import_job.import_accounts {
+        return;
+    }
+
     let tracker = ProgressTracker::new("Reading accounts.json".into(), backend.send.clone());
     modal_action.trackers.push(tracker.clone());
     tracker.notify();
 
-    let accounts_path = path.join("configs/accounts.json");
+    let accounts_path = import_job.root.join("configs/accounts.json");
     let Ok(accounts_bytes) = std::fs::read(&accounts_path) else {
         return;
     };
 
     let Ok(accounts_json) = serde_json::from_slice::<Vec<AtLauncherAccount>>(&accounts_bytes) else {
         return;
     };
-    // let accounts_json = serde_json::from_slice::<Vec<AtLauncherAccount>>(&accounts_bytes).expect("Failed to read account file");
 
     let secret_storage = match backend.secret_storage.get_or_init(PlatformSecretStorage::new).await {
         Ok(secret_storage) => secret_storage,
@@ -348,7 +341,7 @@ async fn import_accounts_from_atlauncher(backend: &BackendState, path: &Path, la
 struct AtLauncherInstanceToImport {
     pandora_path: PathBuf,
     config_path: PathBuf,
-    folder: PathBuf,
+    folder: Arc<Path>,
 }
 
 fn try_load_from_atlauncher(config_path: &Path, launcher_config: &AtLauncherConfig) -> anyhow::Result<InstanceConfiguration> {
@@ -384,24 +377,18 @@ fn try_load_from_atlauncher(config_path: &Path, launcher_config: &AtLauncherConf
     Ok(configuration)
 }
 
-fn import_instances_from_atlauncher(backend: &BackendState, path: &Path, launcher_config: &AtLauncherConfig, modal_action: &ModalAction) {
+fn import_instances_from_atlauncher(backend: &BackendState, import_job: &ImportFromOtherLauncherJob, launcher_config: &AtLauncherConfig, modal_action: &ModalAction) {
+    if import_job.paths.is_empty() {
+        return;
+    }
+
     let all_tracker = ProgressTracker::new("Importing instances".into(), backend.send.clone());
     modal_action.trackers.push(all_tracker.clone());
     all_tracker.notify();
 
-    let Ok(read_dir) = std::fs::read_dir(path.join("instances")) else {
-        all_tracker.set_finished(bridge::modal_action::ProgressTrackerFinishType::Error);
-        all_tracker.notify();
-        return;
-    };
-
     let mut to_import = Vec::new();
 
-    for entry in read_dir {
-        let Ok(entry) = entry else {
-            continue;
-        };
-        let folder = entry.path();
+    for folder in import_job.paths.iter() {
         if !folder.is_dir() {
             continue;
         }
@@ -425,7 +412,7 @@ fn import_instances_from_atlauncher(backend: &BackendState, path: &Path, launche
         to_import.push(AtLauncherInstanceToImport {
             pandora_path,
             config_path: atlauncher_instance_cfg,
-            folder,
+            folder: folder.clone(),
         });
     }
 

crates/backend/src/launcher_import/mod.rs

@@ -1,6 +1,6 @@
-use std::path::Path;
+use std::{path::Path, sync::Arc};
 
-use bridge::{import::{ImportFromOtherLauncher, ImportFromOtherLaunchers, OtherLauncher}, modal_action::ModalAction};
+use bridge::{import::{ImportFromOtherLauncherJob, OtherLauncher}, modal_action::ModalAction};
 use schema::instance::InstanceConfiguration;
 use crate::{BackendState, launcher_import::{
         modrinth::{import_instances_from_modrinth, read_profiles_from_modrinth_db},
@@ -13,39 +13,56 @@ mod multimc;
 mod modrinth;
 mod atlauncher;
 
-pub fn discover_instances_from_other_launchers() -> ImportFromOtherLaunchers {
-    let mut imports = ImportFromOtherLaunchers::default();
-
-    let Some(base_dirs) = directories::BaseDirs::new() else {
-        return imports;
-    };
-    let data_dir = base_dirs.data_dir();
-
-    let prism_instances = data_dir.join("PrismLauncher").join("instances");
-    imports.imports[OtherLauncher::Prism] = from_subfolders(&prism_instances, &|path| {
-        path.join("instance.cfg").exists() && path.join("mmc-pack.json").exists()
-    });
-
-    let multimc_instances = data_dir.join("multimc").join("instances");
-    imports.imports[OtherLauncher::MultiMC] = from_subfolders(&multimc_instances, &|path| {
-        path.join("instance.cfg").exists() && path.join("mmc-pack.json").exists()
-    });
-
-    if let Ok(import) = read_profiles_from_modrinth_db(data_dir) {
-        imports.imports[OtherLauncher::Modrinth] = import;
+pub fn get_import_from_other_launcher_job(other_launcher: OtherLauncher, path: Arc<Path>) -> Option<ImportFromOtherLauncherJob> {
+    if !path.is_dir() {
+        return None;
     }
+    match other_launcher {
+        OtherLauncher::Prism | OtherLauncher::MultiMC => {
+            if !path.join("prismlauncher.cfg").is_file() && !path.join("multimc.cfg").is_file() {
+                return None;
+            }
+            Some(ImportFromOtherLauncherJob {
+                import_accounts: path.join("accounts.json").is_file(),
+                paths: collect_subfolders_matching(&path.join("instances"), &|path| {
+                    path.join("instance.cfg").exists() && path.join("mmc-pack.json").exists()
+                }),
+                root: path,
+            })
+        },
+        OtherLauncher::Modrinth => {
+            let paths = match read_profiles_from_modrinth_db(&path) {
+                Ok(paths) => paths?,
+                Err(err) => {
+                    log::error!("Unable to read modrinth profile database: {err}");
+                    return None;
+                },
+            };
 
-    let atlauncher_instances = data_dir.join("atlauncher").join("instances");
-    imports.imports[OtherLauncher::ATLauncher] = from_subfolders(&atlauncher_instances, &|path| {
-        path.join("instance.json").exists()
-    });
-
-    imports
+            Some(ImportFromOtherLauncherJob {
+                import_accounts: false,
+                paths,
+                root: path,
+            })
+        },
+        OtherLauncher::ATLauncher => {
+            if !path.join("configs/ATLauncher.json").is_file() {
+                return None;
+            }
+            Some(ImportFromOtherLauncherJob {
+                import_accounts: path.join("configs/accounts.json").is_file(),
+                paths: collect_subfolders_matching(&path.join("instances"), &|path| {
+                    path.join("instance.json").exists()
+                }),
+                root: path,
+            })
+        },
+    }
 }
 
-fn from_subfolders(folder: &Path, check: &dyn Fn(&Path) -> bool) -> Option<ImportFromOtherLauncher> {
+fn collect_subfolders_matching(folder: &Path, check: &dyn Fn(&Path) -> bool) -> Vec<Arc<Path>> {
     let Ok(read_dir) = std::fs::read_dir(folder) else {
-        return None;
+        return Vec::new();
     };
     let mut paths = Vec::new();
     for entry in read_dir {
@@ -59,12 +76,9 @@ fn from_subfolders(folder: &Path, check: &dyn Fn(&Path) -> bool) -> Option<Impor
         if !(check)(&path) {
             continue;
         }
-        paths.push(path);
+        paths.push(path.into());
     }
-    Some(ImportFromOtherLauncher {
-        can_import_accounts: true,
-        paths,
-    })
+    paths
 }
 
 pub fn try_load_from_other_launcher_formats(folder: &Path) -> Option<InstanceConfiguration> {
@@ -77,33 +91,20 @@ pub fn try_load_from_other_launcher_formats(folder: &Path) -> Option<InstanceCon
     None
 }
 
-pub async fn import_from_other_launcher(backend: &BackendState, launcher: OtherLauncher, import_accounts: bool, import_instances: bool, modal_action: ModalAction) {
-    let Some(base_dirs) = directories::BaseDirs::new() else {
-        return;
-    };
-    let data_dir = base_dirs.data_dir();
+pub async fn import_from_other_launcher(backend: &BackendState, launcher: OtherLauncher, import_job: ImportFromOtherLauncherJob, modal_action: ModalAction) {
 
     match launcher {
-        OtherLauncher::Prism => {
-            let prism = data_dir.join("PrismLauncher");
-            import_from_multimc(backend, &prism, import_accounts, import_instances, modal_action).await;
+        OtherLauncher::Prism | OtherLauncher::MultiMC => {
+            import_from_multimc(backend, import_job, modal_action).await;
         },
         OtherLauncher::Modrinth => {
-            if import_instances {
-                let modrinth = data_dir.join("ModrinthApp");
-                if let Err(err) = import_instances_from_modrinth(backend, &modrinth, &modal_action) {
-                    log::error!("Sqlite error while importing from modrinth: {err}");
-                    modal_action.set_error_message("Sqlite error while importing from modrinth, see logs for more info".into());
-                }
+            if let Err(err) = import_instances_from_modrinth(backend, import_job, &modal_action) {
+                log::error!("Sqlite error while importing from modrinth: {err}");
+                modal_action.set_error_message("Sqlite error while importing from modrinth, see logs for more info".into());
             }
         },
-        OtherLauncher::MultiMC => {
-            let multimc = data_dir.join("multimc");
-            import_from_multimc(backend, &multimc, import_accounts, import_instances, modal_action).await;
-        },
         OtherLauncher::ATLauncher => {
-            let atlauncher = data_dir.join("atlauncher");
-             import_from_atlauncher(backend, &atlauncher, import_accounts, import_instances, modal_action).await;
+            import_from_atlauncher(backend, import_job, modal_action).await;
         }
     }
 }