refactoring

src/api/app/actions/build/bootstrap.rs

@@ -84,6 +84,7 @@ impl App {
 
     /// Process a single file. Calls [`Self::should_bootstrap_file`] on the file to decide if it should process it
     /// or copy it.
+    #[allow(unused)]
     pub async fn action_bootstrap_file(
         self: Arc<Self>,
         output_base: &Path,

src/api/app/actions/mod.rs

@@ -1,5 +1,4 @@
 mod build;
-mod init;
 mod markdown;
 mod script;
 mod lockfile;

src/api/app/actions/script/mod.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use anyhow::Result;
 
-use crate::api::{app::{App, APP_VERSION}, models::server::Server, tools::java::get_java_installation_for, utils::script::Shell};
+use crate::api::{app::{App, APP_VERSION}, models::server::Server, utils::script::Shell};
 
 impl App {
     async fn get_script_lines_for(&self, shell: &Shell, server: &Server) -> Result<Vec<String>> {

src/api/app/mod.rs

@@ -64,7 +64,7 @@ impl App {
             dirs::cache_dir().map(|p| p.join("mcman"))
         });
 
-        let mut app = Self {
+        let app = Self {
             http_client,
             server: Arc::new(RwLock::new(None)),
             network: Arc::new(RwLock::new(None)),

src/api/app/options/mod.rs

@@ -12,6 +12,8 @@ pub struct AppOptions {
     pub github_token: Option<String>,
     #[config(env = "CF_API_TOKEN")]
     pub curseforge_token: Option<String>,
+    #[config(env = "MODRINTH_API_TOKEN")]
+    pub modrinth_token: Option<String>,
 
     #[config(default = false)]
     pub use_curseforge_api: bool,

src/api/app/step/cache_check.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result};
 use futures::{StreamExt, TryStreamExt};
 use tokio::{fs::File, io::BufWriter};
 use tokio_util::io::ReaderStream;

src/api/app/step/download.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{bail, Context, Result};
 use futures::TryStreamExt;
 
 use crate::api::{app::App, step::{FileMeta, StepResult}, utils::fs::create_parents};

src/api/app/step/remove_file.rs

@@ -1,8 +1,8 @@
 use std::path::Path;
 
-use anyhow::{anyhow, bail, Result};
+use anyhow::Result;
 
-use crate::api::{app::App, step::{FileMeta, StepResult}, tools::{self, java::{JavaProcess, JavaVersion}}};
+use crate::api::{app::App, step::{FileMeta, StepResult}};
 
 impl App {
     pub(super) async fn execute_step_remove_file(

src/api/models/modpack_source.rs

@@ -1,6 +1,6 @@
 use std::{path::Path, str::FromStr};
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
@@ -33,11 +33,15 @@ impl FromStr for ModpackSource {
 impl ModpackSource {
     pub fn accessor(&self, base: &Path) -> Result<Accessor> {
         let str = match self {
-            Self::Local { path } => &base.join(path).to_string_lossy().into_owned(),
+            Self::Local { path } => &base.join(path)
+                .canonicalize()
+                .with_context(|| format!("Resolving path: {:?}", base.join(path)))?
+                .to_string_lossy()
+                .into_owned(),
             Self::Remote { url } => url,
         };
 
-        Ok(Accessor::from(str)?)
+        Ok(Accessor::from(str).with_context(|| "Creating Accessor")?)
     }
 }
 

src/api/models/source.rs

@@ -57,9 +57,12 @@ impl Source {
 
     pub fn accessor(&self, relative_to: &Path) -> Result<Accessor> {
         match &self.source_type {
-            SourceType::File { path } => Ok(Accessor::Local(path.into())),
-            SourceType::Folder { path } => Ok(Accessor::Local(path.into())),
-            SourceType::Modpack { modpack, .. } => modpack.accessor(relative_to),
+            SourceType::File { path } => Ok(Accessor::Local(relative_to.join(path).canonicalize()
+                .with_context(|| format!("Resolving path: {:?}", relative_to.join(path)))?)),
+            SourceType::Folder { path } => Ok(Accessor::Local(relative_to.join(path).canonicalize()
+                .with_context(|| format!("Resolving path: {:?}", relative_to.join(path)))?)),
+            SourceType::Modpack { modpack, .. } => modpack.accessor(relative_to)
+                .with_context(|| "Getting Modpack Accessor"),
         }
     }
 

src/api/sources/github/mod.rs

@@ -34,6 +34,11 @@ impl<'a> GithubAPI<'a> {
         let cached_data = self.0.cache.try_get_json::<CachedData<T>>(&path)?;
 
         let mut headers = HeaderMap::new();
+
+        if let Some(token) = &self.0.options.github_token {
+            headers.insert("Authorization", HeaderValue::from_str(token)?);
+        }
+
         if let Some(cached_data) = &cached_data {
             headers.insert("if-none-match", HeaderValue::from_str(&cached_data.etag)?);
         }

src/api/sources/modrinth/mod.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use anyhow::{anyhow, Result};
 use models::{ModrinthFile, ModrinthProject, ModrinthVersion};
+use reqwest::header::{HeaderMap, HeaderValue};
 use serde::de::DeserializeOwned;
 
 use crate::api::{
@@ -16,7 +17,18 @@ pub struct ModrinthAPI<'a>(pub &'a App);
 
 impl<'a> ModrinthAPI<'a> {
     pub async fn fetch_api<T: DeserializeOwned>(&self, url: String) -> Result<T> {
-        self.0.http_get_json(&*format!("{}/{url}", self.0.options.api_urls.modrinth)).await
+        let mut headers = HeaderMap::new();
+
+        if let Some(token) = &self.0.options.modrinth_token {
+            headers.insert("Authorization", HeaderValue::from_str(token)?);
+        }
+
+        self.0
+            .http_get_json_with(
+                &*format!("{}/{url}", self.0.options.api_urls.modrinth),
+                |req| req.headers(headers),
+            )
+            .await
     }
 
     pub async fn fetch_project(&self, id: &str) -> Result<ModrinthProject> {
@@ -52,7 +64,8 @@ impl<'a> ModrinthAPI<'a> {
             return Ok(id.to_owned());
         }
 
-        let res: ModrinthProjectCheckResponse = self.fetch_api(format!("project/{slug}/check")).await?;
+        let res: ModrinthProjectCheckResponse =
+            self.fetch_api(format!("project/{slug}/check")).await?;
 
         let mut ids = store.unwrap_or_default();
         ids.insert(slug.to_owned(), res.id.clone());
@@ -137,8 +150,6 @@ impl<'a> ModrinthAPI<'a> {
         let id = self.get_id(id).await?;
         let (file, _) = self.fetch_file(&id, version).await?;
 
-        Ok(vec![
-            Step::RemoveFile(FileMeta::filename(file.filename))
-        ])
+        Ok(vec![Step::RemoveFile(FileMeta::filename(file.filename))])
     }
 }

src/api/sources/quilt/mod.rs

@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::Result;
 
 use crate::api::{app::App, models::Environment, step::Step};
 

src/api/tools/git/mod.rs

@@ -1,9 +1,15 @@
-use std::{ffi::OsStr, process::Command};
+use std::{ffi::OsStr, process::Command, sync::LazyLock};
 
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 
 pub const GIT: &str = "git";
 
+static GIT_VERSION: LazyLock<Option<String>> = LazyLock::new(|| version_check());
+
+pub fn require_git() -> Result<()> {
+    GIT_VERSION.as_ref().map(|_| ()).ok_or(anyhow!("Couldn't invoke git"))
+}
+
 pub fn git_command<I: IntoIterator<Item = S>, S: AsRef<OsStr>>(args: I) -> Result<String> {
     Ok(String::from_utf8_lossy(Command::new(GIT)
         .args(args)
@@ -13,8 +19,12 @@ pub fn git_command<I: IntoIterator<Item = S>, S: AsRef<OsStr>>(args: I) -> Resul
     ).into_owned())
 }
 
-pub fn git_check() -> Option<String> {
-    git_command(["--version"]).ok().map(|s| s.replacen("git version ", "", 1))
+pub fn version_check() -> Option<String> {
+    git_command(["--version"]).ok().map(|s| s.trim().replacen("git version ", "", 1))
 }
 
+pub fn is_dirty() -> Result<bool> {
+    require_git()?;
+    Ok(!git_command(["status", "--porcelain"])?.is_empty())
+}
 

src/api/utils/accessor.rs

@@ -11,7 +11,7 @@ use crate::api::app::App;
 pub enum Accessor {
     Local(PathBuf),
     Remote(reqwest::Url),
-    ZipLocal(ZipArchive<std::fs::File>),
+    ZipLocal((PathBuf, ZipArchive<std::fs::File>)),
     //ZipRemote(SomeSortOfTempFile, ZipArchive<std::fs::File>),
 }
 
@@ -20,7 +20,7 @@ impl ToString for Accessor {
         match self {
             Accessor::Local(path) => path.to_string_lossy().into_owned(),
             Accessor::Remote(url) => url.to_string(),
-            Accessor::ZipLocal(_) => String::from("a zip archive"),
+            Accessor::ZipLocal((path ,_)) => path.to_string_lossy().into_owned(),
         }
     }
 }
@@ -32,16 +32,17 @@ impl Accessor {
         } else if str.ends_with(".zip") || str.ends_with(".mrpack") {
             let file = std::fs::File::open(str)?;
             let archive = ZipArchive::new(file)?;
-            Ok(Self::ZipLocal(archive))
+            Ok(Self::ZipLocal((PathBuf::from(str), archive)))
         } else {
             Ok(Self::Local(PathBuf::from(str)))
         }
     }
 
     /// Try listing a directory
+    #[allow(unused)]
     pub async fn dir(&self) -> Result<Vec<String>> {
         match self {
-            Accessor::ZipLocal(zip) => Ok(zip.file_names().map(ToOwned::to_owned).collect()),
+            Accessor::ZipLocal((_, zip)) => Ok(zip.file_names().map(ToOwned::to_owned).collect()),
             Accessor::Local(path) => Ok(path
                 .read_dir()?
                 .filter_map(|r| r.ok())
@@ -57,7 +58,7 @@ impl Accessor {
             Accessor::Local(base) => Ok(serde_json::from_reader(std::fs::File::open(
                 base.join(path),
             )?)?),
-            Accessor::ZipLocal(zip) => Ok(serde_json::from_reader(zip.by_name(path)?)?),
+            Accessor::ZipLocal((_, zip)) => Ok(serde_json::from_reader(zip.by_name(path)?)?),
             Accessor::Remote(url) => Ok(app.http_get_json(url.join(path)?).await?),
         }
     }
@@ -68,7 +69,7 @@ impl Accessor {
             Accessor::Local(base) => Ok(toml::from_str(
                 &tokio::fs::read_to_string(base.join(path)).await?,
             )?),
-            Accessor::ZipLocal(zip) => {
+            Accessor::ZipLocal((_, zip)) => {
                 let file = zip.by_name(path)?;
 
                 Ok(toml::from_str(&std::io::read_to_string(file)?)?)

src/api/ws/msg.rs

@@ -1,12 +1,17 @@
+
+
 use serde::{Deserialize, Serialize};
 use tokio_tungstenite::tungstenite::Message;
 
-use crate::api::models::{network::Network, server::Server};
+use crate::api::models::{network::Network, server::Server, Source};
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(tag = "type", content = "data", rename_all = "snake_case")]
 pub enum MsgIn {
-
+    AddSource {
+        to: ServerOrNetwork,
+        source: Source,
+    },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]

src/commands/mod.rs

@@ -6,3 +6,4 @@ pub mod markdown;
 pub mod migrate;
 pub mod websocket;
 pub mod run;
+pub mod update;

src/commands/run.rs

@@ -1,8 +1,8 @@
-use std::{path::PathBuf, sync::Arc};
+use std::sync::Arc;
 
-use anyhow::{bail, Context, Result};
+use anyhow::Result;
 
-use crate::api::{app::App, tools::java::{get_java_installation_for, JavaProcess}, ws::WebsocketServer};
+use crate::api::{app::App, tools::java::JavaProcess};
 
 #[derive(clap::Args)]
 pub struct RunArgs {

src/commands/sources/list.rs

@@ -1,16 +1,31 @@
 use std::sync::Arc;
 
 use anyhow::Result;
+use console::style;
 
-use crate::api::app::App;
+use crate::api::{app::App, models::{ModpackSource, SourceType}};
 
 #[derive(clap::Args)]
 pub struct Args {}
 
 pub async fn run(app: Arc<App>, args: Args) -> Result<()> {
     let sources = app.collect_sources().await?;
 
-    println!("{sources:#?}");
+    for (idx, (base, source)) in sources.iter().enumerate() {
+        println!(
+            "{} {}{}",
+            style(idx.to_string() + ".").cyan().bold(),
+            style(source.source_name()).bold(),
+            match source.source_type {
+                SourceType::Modpack { modpack_type, .. } => format!(
+                    "/{}", style(modpack_type.to_string()).bold()
+                ),
+                _ => String::new(),
+            }
+        );
+
+        println!("   -> {}", style(source.accessor(base)?.to_string()).dim())
+    }
 
     Ok(())
 }

src/commands/update.rs

@@ -0,0 +1,17 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+
+use crate::api::{app::App, tools::git::version_check};
+
+#[derive(clap::Args)]
+pub struct Args {
+
+}
+
+pub async fn run(app: Arc<App>, args: Args) -> Result<()> {
+    println!("{:#?}", version_check());
+
+    Ok(())
+}
+

src/main.rs

@@ -33,6 +33,9 @@ enum Commands {
     #[command(alias = "md", subcommand)]
     Markdown(commands::markdown::Commands),
     Migrate(commands::migrate::Args),
+    #[command(alias = "ws")]
+    WebSocket(commands::websocket::Args),
+    Update(commands::update::Args),
 }
 
 #[tokio::main]
@@ -66,5 +69,7 @@ async fn main() -> Result<()> {
         Commands::Java(args) => commands::java::run(app, args).await,
         Commands::Markdown(args) => commands::markdown::run(app, args).await,
         Commands::Migrate(args) => commands::migrate::run(app, args).await,
+        Commands::WebSocket(args) => commands::websocket::run(app, args).await,
+        Commands::Update(args) => commands::update::run(app, args).await,
     }
 }