javamc 0.1.0

Cross-platform CLI to download and run the official Mojang Java runtimes bundled with Minecraft.
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use clap::{Parser, Subcommand};
use piston_mc::java::{JavaManifest, JavaRuntime};
use simple_download_utility::MultiDownloadProgress;
use std::path::{Path, PathBuf};

#[derive(Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct MCJavaArgs {
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand, Debug)]
enum Command {
    /// Lists all available java versions
    List,

    /// Downloads a java version to the given directory
    Download {
        /// The java version to download
        version: String,

        /// The directory to download the version into
        directory: PathBuf,
    },

    /// Downloads (if needed) and executes a java version, forwarding any extra args
    Execute {
        /// The java version to execute
        version: String,

        /// The directory to download the version into
        directory: PathBuf,

        /// Arguments passed through to the java executable
        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
        java_args: Vec<String>,
    },
}

#[tokio::main]
async fn main() {
    let args = MCJavaArgs::parse();

    match args.command {
        Command::List => {
            let list = list().await;
            println!("Available Java versions:");
            for rt in list {
                println!("{:<20} ({})", rt.version.name, rt.version.released)
            }
        }
        Command::Download { version, directory } => {
            download(version, directory).await;
        }
        Command::Execute {
            version,
            directory,
            java_args,
        } => {
            execute(version, directory, java_args).await;
        }
    }
}

async fn download(version: String, directory: PathBuf) {
    // Get the gamma runtime (Java 17) for Windows x64
    let list = list().await;
    if let Some(runtime) = list.iter().find(|v| v.version.name == version) {
        let (sender, mut receiver) = tokio::sync::mpsc::channel::<MultiDownloadProgress>(16);
        let task = runtime.install(directory, 100, Some(sender));

        tokio::spawn(async move {
            while let Some(progress) = receiver.recv().await {
                let percent =
                    (progress.files_downloaded as f32 / progress.files_total as f32) * 100.0;

                let mb_per_sec = progress.bytes_per_second as f32 / 1024.0 / 1024.0;

                println!(
                    "Installing Java: {:.2}% ({}/{} files) {:.2} MB/s",
                    percent, progress.files_downloaded, progress.files_total, mb_per_sec
                );
            }
        });

        task.await.expect("Failed to install Java runtime");

        println!("Java runtime installed successfully");
    }
}

async fn execute(version: String, directory: PathBuf, java_args: Vec<String>) {
    if !Path::exists(&directory.join("bin")) {
        download(version.clone(), directory.clone()).await;
    }

    // Resolve the platform-specific java executable inside the runtime's bin directory.
    let java_exe = if cfg!(windows) { "java.exe" } else { "java" };
    let java_path = directory.join("bin").join(java_exe);

    // Hand control over to java: stdio is inherited by default, so Minecraft's
    // stdin/stdout (the server console) works exactly as if java were run directly.
    // The child inherits our working directory, so relative paths like `server.jar`
    // resolve against the caller's cwd, matching a direct java invocation.
    let status = tokio::process::Command::new(&java_path)
        .args(&java_args)
        .status()
        .await;

    match status {
        Ok(status) => std::process::exit(status.code().unwrap_or(0)),
        Err(e) => {
            eprintln!("Failed to execute Java at {}: {}", java_path.display(), e);
            std::process::exit(1);
        }
    }
}

async fn list() -> Vec<JavaRuntime> {
    let manifest = match JavaManifest::fetch().await {
        Ok(items) => items,
        Err(e) => {
            eprintln!("Failed to get the list of java versions from Mojang.");
            eprintln!("{}", e);
            std::process::exit(1);
        }
    };
    let runtime = {
        #[cfg(all(target_os = "windows", target_arch = "x86"))]
        {
            manifest.windows_x86
        }
        #[cfg(all(target_os = "windows", target_arch = "x86_64"))]
        {
            manifest.windows_x64
        }

        #[cfg(all(target_os = "macos", target_arch = "x86_64"))]
        {
            manifest.macos
        }
        #[cfg(all(target_os = "macos", target_arch = "arm"))]
        {
            manifest.macos_arm64
        }
        #[cfg(all(target_os = "linux", target_arch = "x86_64"))]
        {
            manifest.linux
        }
        #[cfg(all(target_os = "linux", target_arch = "arm"))]
        {
            manifest.linux_i386
        }
    };
    let mut runtimes: Vec<JavaRuntime> = vec![];
    runtimes.extend(runtime.alpha);
    runtimes.extend(runtime.beta);
    runtimes.extend(runtime.gamma);
    runtimes.extend(runtime.delta);
    runtimes.extend(runtime.gamma_snapshot);
    runtimes.extend(runtime.epsilon);
    runtimes.extend(runtime.legacy);
    runtimes.sort_by(|a, b| b.version.released.cmp(&a.version.released));
    runtimes
}