mod management

README.md

@@ -1,7 +1,5 @@
 # UML (untitled minecraft launcher)
-This is a VERY work in progress minecraft launcher.
+This is a custom CLI Minecraft launcher made in Rust.
-More info will be available soon.
+More info is at [uml.rs](https://uml.rs)
-Sorry about it.
 
-## THIS IS ONLY AVAILABLE ON LINUX RIGHT NOW
+## THIS IS ONLY AVAILABLE ON LINUX
-and windows/macos/others will probably not be supported, go use prismlauncher (its the better one anyway, for now at least...)

src/auth.rs

@@ -114,7 +114,7 @@ fn refresh(agent: &Agent, refresh: &str) -> anyhow::Result<(String, String)> {
 }
 fn poll(agent: &Agent, device: &Device) -> anyhow::Result<(String, String)> {
     println!(
-        "Go to {} and enter code: {}",
+        "Go to {} and enter code: {}.",
         device.verification_uri, device.user_code
     );
     loop {

src/content.rs

@@ -0,0 +1,116 @@
+use std::path::Path;
+pub struct ModEntry {
+    pub filename: String,
+    pub enabled: bool,
+    pub id: String,
+    pub name: Option<String>,
+}
+#[derive(serde::Deserialize)]
+struct FabricModJson {
+    id: String,
+    #[serde(default)]
+    name: Option<String>,
+}
+
+fn read_mod_meta(jar_path: &Path) -> Option<(String, Option<String>)> {
+    let file = std::fs::File::open(jar_path).ok()?;
+    let mut archive = zip::ZipArchive::new(file).ok()?;
+    let entry = archive.by_name("fabric.mod.json").ok()?;
+    let meta: FabricModJson = serde_json::from_reader(entry).ok()?;
+    Some((meta.id, meta.name))
+}
+fn entry_from_name(dir: &Path, name: String) -> Option<ModEntry> {
+    let jar = dir.join(&name);
+    let enabled = if name.ends_with(".jar") {
+        true
+    } else if name.ends_with(".jar.disabled") {
+        false
+    } else {
+        return None;
+    };
+    let (id, pretty) = match read_mod_meta(&jar) {
+        Some(info) => info,
+        None => {
+            let base = name
+                .strip_suffix(".disabled")
+                .unwrap_or(&name)
+                .strip_suffix(".jar")
+                .unwrap_or(&name)
+                .to_string();
+            (base, None)
+        }
+    };
+    Some(ModEntry {
+        filename: name,
+        enabled,
+        id,
+        name: pretty,
+    })
+}
+pub fn list(dir: &Path) -> anyhow::Result<Vec<ModEntry>> {
+    if !dir.exists() {
+        return Ok(Vec::new());
+    }
+    let mut mods = Vec::new();
+    for e in std::fs::read_dir(dir)? {
+        let name = e?.file_name().to_string_lossy().to_string();
+        if let Some(entry) = entry_from_name(dir, name) {
+            mods.push(entry);
+        }
+    }
+    mods.sort_by_key(|m| m.filename.clone());
+    Ok(mods)
+}
+pub fn disable(dir: &Path, item: &str) -> anyhow::Result<()> {
+    let entries = list(dir)?;
+    let entry = entries
+        .iter()
+        .find(|m| m.id == item || m.filename == item)
+        .ok_or_else(|| anyhow::anyhow!("no mod matching {item}"))?;
+    if !entry.enabled {
+        println!("{item} is already disabled");
+        return Ok(());
+    }
+    let new_name = format!("{}.disabled", entry.filename);
+    std::fs::rename(dir.join(&entry.filename), dir.join(&new_name))?;
+    Ok(())
+}
+
+pub fn enable(dir: &Path, item: &str) -> anyhow::Result<()> {
+    let entries = list(dir)?;
+    let entry = entries
+        .iter()
+        .find(|m| m.id == item || m.filename == item)
+        .ok_or_else(|| anyhow::anyhow!("no mod matching {item}"))?;
+    if entry.enabled {
+        println!("{item} is already enabled");
+        return Ok(());
+    }
+    let new_name = entry.filename.strip_suffix(".disabled").unwrap();
+    std::fs::rename(dir.join(&entry.filename), dir.join(new_name))?;
+    Ok(())
+}
+
+pub fn delete(dir: &Path, item: &str) -> anyhow::Result<()> {
+    let entries = list(dir)?;
+    let entry = entries
+        .iter()
+        .find(|m| m.id == item || m.filename == item)
+        .ok_or_else(|| anyhow::anyhow!("no mod matching {item}"))?;
+    std::fs::remove_file(dir.join(&entry.filename))?;
+    Ok(())
+}
+pub fn add(dir: &Path, source: &Path) -> anyhow::Result<()> {
+    if !source.is_file() {
+        anyhow::bail!("not a file: {}", source.display());
+    }
+    let filename = source
+        .file_name()
+        .ok_or_else(|| anyhow::anyhow!("invalid source path"))?;
+    let dest = dir.join(filename);
+    if dest.exists() {
+        anyhow::bail!("a mod named {:?} already exists", filename);
+    }
+    std::fs::copy(source, &dest)?;
+    Ok(())
+}

src/instance.rs

@@ -1,9 +1,10 @@
-use anyhow::Ok;
 use serde::{Deserialize, Serialize};
 use std::{
     fs::create_dir_all,
     path::{Path, PathBuf},
 };
+
+use crate::util::is_valid_name;
 #[derive(Serialize, Deserialize)]
 pub struct Instance {
     pub version: String,
@@ -18,8 +19,8 @@ pub struct Loader {
 }
 
 pub fn create(instances_dir: &Path, name: &str, version: &str) -> anyhow::Result<PathBuf> {
-    if name.contains('/') {
+    if !is_valid_name(name) {
-        anyhow::bail!("unusable characters in path.");
+        anyhow::bail!("invalid instance name: {name:?}");
     }
     let directory = instances_dir.join(name);
     if directory.join("instance.json").exists() {
@@ -63,6 +64,9 @@ pub fn list(root: &Path) -> anyhow::Result<Vec<String>> {
     Ok(out)
 }
 pub fn remove(instances_dir: &Path, name: &str, yes: bool) -> anyhow::Result<()> {
+    if !is_valid_name(name) {
+        anyhow::bail!("invalid instance name: {name:?}");
+    }
     let dir = instances_dir.join(&name);
     if !dir.exists() {
         anyhow::bail!("no instance named {name}");
@@ -77,7 +81,25 @@ pub fn remove(instances_dir: &Path, name: &str, yes: bool) -> anyhow::Result<()>
         }
     }
     std::fs::remove_dir_all(&dir)?;
-    println!("Removed {name}.");
+    Ok(())
+}
+pub fn rename(instances_dir: &Path, old_name: &str, new_name: &str) -> anyhow::Result<()> {
+    if !is_valid_name(old_name) {
+        anyhow::bail!("invalid original instance name: {old_name:?}");
+    }
+    if !is_valid_name(new_name) {
+        anyhow::bail!("invalid new instance name: {new_name:?}");
+    }
+    let instance_dir = instances_dir.join(&old_name);
+    let new_dir = instances_dir.join(&new_name);
+    if !instance_dir.exists() {
+        anyhow::bail!("original instance name doesn't exist");
+    }
+    if new_dir.exists() {
+        anyhow::bail!("new instance name already exists");
+    }
+    std::fs::rename(instance_dir, new_dir)?;
+
     Ok(())
 }
 pub fn sanitize(name: &str) -> String {

src/main.rs

@@ -1,4 +1,8 @@
+#[cfg(not(target_os = "linux"))]
+compile_error!("UML only supports Linux.");
+
 mod auth; // this is painful, ai helped a bit btw (i try to use ai as little as possible, but this part's just ANNOYING)
+mod content;
 mod download;
 mod fabric;
 mod instance;
@@ -6,13 +10,20 @@ mod launch;
 mod meta;
 mod mrpack;
 mod prism;
-use crate::{launch::run, meta::fetch_version};
+mod util;
 use clap::{Parser, Subcommand};
+use launch::run;
+use meta::fetch_version;
 use std::path::{Path, PathBuf};
 
+use crate::util::{is_valid_name, open_path};
+
 /// Untitled Minecraft Launcher
 #[derive(Parser)]
 #[command(name = "uml")]
+#[command(
+    after_help = "For any instance names with spaces, other than the launch command, enclose it in double quotes."
+)]
 struct Cli {
     #[command(subcommand)]
     command: Command,
@@ -21,6 +32,25 @@ struct Cli {
 enum LoaderKind {
     Fabric,
 }
+
+#[derive(Subcommand)]
+enum ModVerb {
+    List,
+    Add {
+        path: PathBuf,
+    },
+    Enable {
+        item: String,
+    },
+    Disable {
+        item: String,
+    },
+    #[command(alias = "remove")]
+    Delete {
+        item: String,
+    },
+}
+
 #[derive(Subcommand)]
 enum Command {
     /// Launch an instance
@@ -32,13 +62,27 @@ enum Command {
         // #[arg(long)]
         // offline: bool,
     },
+    /// Manage things inside instances (mods, worlds, etc...)
+    Instance {
+        name: String,
+        #[command(subcommand)]
+        action: InstanceAction,
+    },
     /// Manage instances
     Instances {
         #[command(subcommand)]
         action: InstanceCmd,
     },
+    /// Open an instance folder
+    Folder { name: String },
+}
+#[derive(Subcommand)]
+enum InstanceAction {
+    Mods {
+        #[command(subcommand)]
+        verb: ModVerb,
+    },
 }
-
 #[derive(Subcommand)]
 enum InstanceCmd {
     /// Create a new instance
@@ -47,6 +91,11 @@ enum InstanceCmd {
         #[arg(long)]
         version: String,
     },
+    /// Rename an instance
+    Rename {
+        current_name: String,
+        new_name: String,
+    },
     /// Import a Modrinth modpack
     Import {
         pack: PathBuf,
@@ -97,6 +146,16 @@ fn main() -> anyhow::Result<()> {
 
     let cli = Cli::parse();
     match cli.command {
+        Command::Folder { name } => {
+            if !is_valid_name(&name) {
+                anyhow::bail!("invalid instance name: {name:?}");
+            }
+            let dir = instances_dir.join(&name);
+            if !dir.exists() {
+                anyhow::bail!("no instance named {name}");
+            }
+            open_path(&dir)?;
+        }
         Command::Instances { action } => match action {
             InstanceCmd::New { name, version } => {
                 if !meta::version_exists(&version)? {
@@ -104,6 +163,13 @@ fn main() -> anyhow::Result<()> {
                 }
                 instance::create(&instances_dir, &name, &version)?;
             }
+            InstanceCmd::Rename {
+                current_name,
+                new_name,
+            } => {
+                instance::rename(&instances_dir, &current_name, &new_name)?;
+                println!("Renamed {} to {}.", current_name, new_name);
+            }
             InstanceCmd::Import { pack, name, yes } => {
                 mrpack::import(&pack, &instances_dir, name.as_deref(), yes)?;
             }
@@ -112,6 +178,7 @@ fn main() -> anyhow::Result<()> {
             }
             InstanceCmd::Remove { name, yes } => {
                 instance::remove(&instances_dir, &name, yes)?;
+                println!("Removed {name}.");
             }
             InstanceCmd::List => {
                 for n in instance::list(&instances_dir)? {
@@ -191,6 +258,36 @@ fn main() -> anyhow::Result<()> {
                 &game_version,
             )?;
         }
+        Command::Instance { name, action } => {
+            if !is_valid_name(&name) {
+                anyhow::bail!("invalid instance name: {name:?}");
+            }
+            let mods_dir = instances_dir.join(&name).join("mods");
+            match action {
+                InstanceAction::Mods { verb } => match verb {
+                    ModVerb::List => {
+                        let mods = content::list(&mods_dir)?;
+                        if mods.is_empty() {
+                            println!("No mods installed.");
+                        } else {
+                            for m in content::list(&mods_dir)? {
+                                let display = m.name.as_deref().unwrap_or(&m.id);
+                                if m.enabled {
+                                    println!("{display}  ({})", m.id);
+                                } else {
+                                    println!("{display}  ({}) (disabled)", m.id);
+                                }
+                            }
+                            println!("Make sure to specify mods by the ID.");
+                        }
+                    }
+                    ModVerb::Add { path } => content::add(&mods_dir, &path)?,
+                    ModVerb::Enable { item } => content::enable(&mods_dir, &item)?,
+                    ModVerb::Disable { item } => content::disable(&mods_dir, &item)?,
+                    ModVerb::Delete { item } => content::delete(&mods_dir, &item)?,
+                },
+            }
+        }
     }
     Ok(())
 }

src/mrpack.rs

@@ -1,7 +1,7 @@
 use crate::{
-    download::download,
+    download::{download, verify_sha512},
-    download::verify_sha512,
     instance::{Loader, create, load, save},
+    util::is_safe_relative_path,
 };
 use indicatif::{ProgressBar, ProgressStyle};
 use serde::Deserialize;
@@ -51,10 +51,9 @@ fn extract_overrides(
         if rel.is_empty() || entry.is_dir() {
             continue;
         }
-        if rel.contains("..") || rel.starts_with('/') {
+        if !is_safe_relative_path(rel) {
             anyhow::bail!("suspicious path in pack: {name}");
         }
-
         let dest = instance_dir.join(rel);
         if let Some(parent) = dest.parent() {
             std::fs::create_dir_all(parent)?;
@@ -146,7 +145,7 @@ pub fn import(
     pb.set_style(ProgressStyle::with_template("{bar:40} {pos}/{len} {msg}").unwrap());
 
     for f in &wanted {
-        if f.path.contains("..") || f.path.starts_with('/') {
+        if !is_safe_relative_path(&f.path) {
             anyhow::bail!("suspicious path in pack: {}", f.path);
         }
         pb.set_message(f.path.clone());

src/util.rs

@@ -0,0 +1,19 @@
+use std::path::Path;
+
+pub fn is_valid_name(name: &str) -> bool {
+    let mut components = Path::new(name).components();
+    matches!(
+        (components.next(), components.next()),
+        (Some(std::path::Component::Normal(_)), None)
+    )
+}
+pub fn is_safe_relative_path(path: &str) -> bool {
+    let p = Path::new(path);
+    !p.as_os_str().is_empty()
+        && p.components()
+            .all(|c| matches!(c, std::path::Component::Normal(_)))
+}
+pub fn open_path(path: &Path) -> anyhow::Result<()> {
+    std::process::Command::new("xdg-open").arg(path).spawn()?;
+    Ok(())
+}