Profile bindings (#55)

* basic framework. still has errors

* added functionality for main endpoints + some structuring

* formatting

* unused code

* mimicked CLI function with wait_for process

* made PR changes, added playground

* cargo fmt

* removed missed println

* misc tests fixes

* cargo fmt

* added windows support

* cargo fmt

* all OS use dunce

* restructured profile slightly; fixed mac bug

* profile changes, new main.rs

* fixed requested pr + canonicaliation bug

* fixed regressed bug in ui

* fixed regressed bugs

* fixed git error

* typo

* ran prettier

* clippy

* playground clippy

* ported profile loading fix

* profile change for real, url println and clippy

* PR changes

---------

Co-authored-by: Wyatt <wyatt@modrinth.com>

theseus/src/api/mod.rs

@@ -1,6 +1,7 @@
 //! API for interacting with Theseus
 pub mod auth;
 pub mod profile;
+pub mod profile_create;
 
 pub mod data {
     pub use crate::state::{
@@ -14,6 +15,6 @@ pub mod prelude {
         auth::{self, Credentials},
         data::*,
         profile::{self, Profile},
-        State,
+        profile_create, State,
     };
 }

theseus/src/api/profile.rs

@@ -7,8 +7,12 @@ use daedalus as d;
 use std::{
     future::Future,
     path::{Path, PathBuf},
+    sync::Arc,
+};
+use tokio::{
+    process::{Child, Command},
+    sync::RwLock,
 };
-use tokio::process::{Child, Command};
 
 /// Add a profile to the in-memory state
 #[tracing::instrument]
@@ -105,11 +109,12 @@ pub async fn list(
 }
 
 /// Run Minecraft using a profile
+/// Returns Arc pointer to RwLock to Child
 #[tracing::instrument(skip_all)]
 pub async fn run(
     path: &Path,
     credentials: &crate::auth::Credentials,
-) -> crate::Result<Child> {
+) -> crate::Result<Arc<RwLock<Child>>> {
     let state = State::get().await.unwrap();
     let settings = state.settings.read().await;
     let profile = get(path).await?.ok_or_else(|| {
@@ -199,7 +204,7 @@ pub async fn run(
     let memory = profile.memory.unwrap_or(settings.memory);
     let resolution = profile.resolution.unwrap_or(settings.game_resolution);
 
-    crate::launcher::launch_minecraft(
+    let mc_process = crate::launcher::launch_minecraft(
         &profile.metadata.game_version,
         &profile.metadata.loader_version,
         &profile.path,
@@ -210,7 +215,18 @@ pub async fn run(
         &resolution,
         credentials,
     )
-    .await
+    .await?;
+
+    // Insert child into state
+    let mut state_children = state.children.write().await;
+    let pid = mc_process.id().ok_or_else(|| {
+        crate::ErrorKind::LauncherError(
+            "Process failed to stay open.".to_string(),
+        )
+    })?;
+    let child_arc = state_children.insert(pid, mc_process);
+
+    Ok(child_arc)
 }
 
 #[tracing::instrument]

theseus/src/api/profile_create.rs

@@ -0,0 +1,165 @@
+//! Theseus profile management interface
+use crate::{prelude::ModLoader, profile};
+pub use crate::{
+    state::{JavaSettings, Profile},
+    State,
+};
+use daedalus::modded::LoaderVersion;
+use dunce::canonicalize;
+use futures::prelude::*;
+use std::path::PathBuf;
+use tokio::fs;
+use tokio_stream::wrappers::ReadDirStream;
+use uuid::Uuid;
+
+const DEFAULT_NAME: &str = "Untitled Instance";
+
+// Generic basic profile creation tool.
+// Creates an essentially empty dummy profile with profile_create
+#[tracing::instrument]
+pub async fn profile_create_empty() -> crate::Result<PathBuf> {
+    profile_create(
+        String::from(DEFAULT_NAME), // the name/path of the profile
+        String::from("1.19.2"),     // the game version of the profile
+        ModLoader::Vanilla,         // the modloader to use
+        String::from("stable"), // the modloader version to use, set to "latest", "stable", or the ID of your chosen loader
+        None,                   // the icon for the profile
+    )
+    .await
+}
+
+// Creates a profile at  the given filepath and adds it to the in-memory state
+// Returns filepath at which it can be accessed in the State
+#[tracing::instrument]
+pub async fn profile_create(
+    name: String,           // the name of the profile, and relative path
+    game_version: String,   // the game version of the profile
+    modloader: ModLoader,   // the modloader to use
+    loader_version: String, // the modloader version to use, set to "latest", "stable", or the ID of your chosen loader
+    icon: Option<PathBuf>,  // the icon for the profile
+) -> crate::Result<PathBuf> {
+    let state = State::get().await?;
+
+    let uuid = Uuid::new_v4();
+    let path = state.directories.profiles_dir().join(uuid.to_string());
+
+    if path.exists() {
+        if !path.is_dir() {
+            return Err(ProfileCreationError::NotFolder.into());
+        }
+        if path.join("profile.json").exists() {
+            return Err(ProfileCreationError::ProfileExistsError(
+                path.join("profile.json"),
+            )
+            .into());
+        }
+
+        if ReadDirStream::new(fs::read_dir(&path).await?)
+            .next()
+            .await
+            .is_some()
+        {
+            return Err(ProfileCreationError::NotEmptyFolder.into());
+        }
+    } else {
+        fs::create_dir_all(&path).await?;
+    }
+    println!(
+        "Creating profile at path {}",
+        &canonicalize(&path)?.display()
+    );
+
+    let loader = modloader;
+    let loader = if loader != ModLoader::Vanilla {
+        let version = loader_version;
+
+        let filter = |it: &LoaderVersion| match version.as_str() {
+            "latest" => true,
+            "stable" => it.stable,
+            id => it.id == *id,
+        };
+
+        let loader_data = match loader {
+            ModLoader::Forge => &state.metadata.forge,
+            ModLoader::Fabric => &state.metadata.fabric,
+            _ => {
+                return Err(ProfileCreationError::NoManifest(
+                    loader.to_string(),
+                )
+                .into())
+            }
+        };
+
+        let loaders = &loader_data
+            .game_versions
+            .iter()
+            .find(|it| it.id == game_version)
+            .ok_or_else(|| {
+                ProfileCreationError::ModloaderUnsupported(
+                    loader.to_string(),
+                    game_version.clone(),
+                )
+            })?
+            .loaders;
+
+        let loader_version = loaders
+            .iter()
+            .cloned()
+            .find(filter)
+            .or(
+                // If stable was searched for but not found, return latest by default
+                if version == "stable" {
+                    loaders.iter().next().cloned()
+                } else {
+                    None
+                },
+            )
+            .ok_or_else(|| {
+                ProfileCreationError::InvalidVersionModloader(
+                    version,
+                    loader.to_string(),
+                )
+            })?;
+
+        Some((loader_version, loader))
+    } else {
+        None
+    };
+
+    // Fully canonicalize now that its created for storing purposes
+    let path = canonicalize(&path)?;
+    let mut profile = Profile::new(name, game_version, path.clone()).await?;
+    if let Some(ref icon) = icon {
+        profile.with_icon(icon).await?;
+    }
+    if let Some((loader_version, loader)) = loader {
+        profile.with_loader(loader, Some(loader_version));
+    }
+
+    profile::add(profile).await?;
+    State::sync().await?;
+
+    Ok(path)
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum ProfileCreationError {
+    #[error("Profile .json exists: {0}")]
+    ProfileExistsError(PathBuf),
+    #[error("Modloader {0} unsupported for Minecraft version {1}")]
+    ModloaderUnsupported(String, String),
+    #[error("Invalid version {0} for modloader {1}")]
+    InvalidVersionModloader(String, String),
+    #[error("Could not get manifest for loader {0}. This is a bug in the GUI")]
+    NoManifest(String),
+    #[error("Could not get State.")]
+    NoState,
+
+    #[error("Attempted to create project in something other than a folder.")]
+    NotFolder,
+    #[error("You are trying to create a profile in a non-empty directory")]
+    NotEmptyFolder,
+
+    #[error("IO error: {0}")]
+    IOError(#[from] std::io::Error),
+}