rmcl 0.3.0

A fully featured Minecraft launcher TUI
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

// modpack importing from modrinth (remote slug/url) or local files (.mrpack, mmc zips).
// resolves the input, downloads if needed, then hands off to the import engine.
use clap::ArgMatches;

use crate::instance::InstanceManager;
use crate::instance::import::{ImportInput, parse_import_input};
use crate::net::modrinth;

type CliResult = Result<(), Box<dyn std::error::Error>>;

pub async fn handle_import(matches: &ArgMatches) -> CliResult {
    let input = matches.get_one::<String>("source").unwrap();
    let override_name = matches.get_one::<String>("name");
    let override_version = matches.get_one::<String>("version");

    let instances_dir = crate::config::SETTINGS.paths.resolve_instances_dir();
    let meta_dir = crate::config::SETTINGS.paths.resolve_meta_dir();
    let manager = InstanceManager::new(instances_dir, meta_dir);
    let client = crate::net::HttpClient::new();

    let parsed = parse_import_input(input);

    let archive_path = match parsed {
        ImportInput::LocalFile(ref path) => {
            let resolved = crate::config::settings::resolve_path(path);
            if !resolved.exists() {
                return Err(format!("File not found: {}", resolved.display()).into());
            }
            resolved
        }
        ImportInput::ProjectSlug(ref slug) => {
            println!("Fetching project '{slug}'...");
            let project = modrinth::fetch_project(&client, slug)
                .await
                .map_err(|e| format!("Failed to fetch project: {e}"))?;
            println!("Found: {}", project.title);

            let versions = modrinth::fetch_versions(&client, slug)
                .await
                .map_err(|e| format!("Failed to fetch versions: {e}"))?;

            if versions.is_empty() {
                return Err("No versions found for this modpack".into());
            }

            let version = if let Some(version_name) = override_version {
                versions
                    .iter()
                    .find(|v| v.version_number == *version_name || v.name == *version_name)
                    .ok_or_else(|| format!("Version '{version_name}' not found"))?
            } else {
                &versions[0]
            };

            println!(
                "Using version {} ({})",
                version.version_number,
                version.game_versions.first().unwrap_or(&"?".to_string())
            );

            let tmp_dir = manager.meta_dir.join("tmp");
            std::fs::create_dir_all(&tmp_dir)?;
            modrinth::download_mrpack(&client, version, &tmp_dir)
                .await
                .map_err(|e| format!("Failed to download .mrpack: {e}"))?
        }
        ImportInput::VersionId {
            slug: _,
            ref version_id,
        } => {
            println!("Fetching version '{version_id}'...");
            let version = modrinth::fetch_version(&client, version_id)
                .await
                .map_err(|e| format!("Failed to fetch version: {e}"))?;

            println!(
                "Found: {} ({})",
                version.version_number,
                version.game_versions.first().unwrap_or(&"?".to_string())
            );

            let tmp_dir = manager.meta_dir.join("tmp");
            std::fs::create_dir_all(&tmp_dir)?;
            modrinth::download_mrpack(&client, &version, &tmp_dir)
                .await
                .map_err(|e| format!("Failed to download .mrpack: {e}"))?
        }
    };

    let mut summary = crate::instance::import::build_summary(&archive_path)
        .map_err(|e| format!("Invalid modpack: {e}"))?;

    if let Some(name) = override_name {
        summary.name = name.clone();
    }

    println!(
        "Importing '{}' — {} {} ({} mods, {} overrides)",
        summary.name,
        summary.game_version,
        summary.loader,
        summary.mod_count,
        summary.override_count
    );

    let config = crate::instance::import::execute_import(&summary, &manager)
        .await
        .map_err(|e| format!("Import failed: {e}"))?;

    println!("Instance '{}' created successfully.", config.name);
    Ok(())
}