do some work

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

@@ -0,0 +1,36 @@
+use std::{path::Path, sync::Arc};
+
+use anyhow::{Context, Result};
+use futures::{stream, StreamExt, TryStreamExt};
+
+use crate::api::{app::App, models::Addon};
+
+impl App {
+    pub async fn action_install_addons(self: Arc<Self>, base: &Path) -> Result<()> {
+        let addons = self.collect_addons().await?;
+        let base = Arc::new(base.to_owned());
+
+        const MAX_CONCURRENT_TASKS: usize = 20;
+
+        stream::iter(addons).map(Ok).try_for_each_concurrent(
+            Some(MAX_CONCURRENT_TASKS),
+            move |addon| {
+                let app = self.clone();
+                let base = base.clone();
+                async move {
+                    app.action_install_addon(&base, &addon).await
+                        .with_context(|| format!("{addon:#?}"))
+                }
+            }
+        ).await?;
+
+        Ok(())
+    }
+
+    pub async fn action_install_addon(self: Arc<Self>, base: &Path, addon: &Addon) -> Result<()> {
+        let steps = addon.resolve_steps(&self).await?;
+        let dir = base.join(addon.target.as_str());
+        self.execute_steps(&dir, &steps).await?;
+        Ok(())
+    }
+}

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

@@ -5,47 +5,16 @@ use anyhow::Result;
 
 use crate::api::{app::App, models::{Addon, Environment}};
 
-impl App {
-    pub async fn action_install_jar(&self, base: &Path) -> Result<()> {
-        if let Some(jar) = self.server.read().await.as_ref().map(|(_, server)| {
-            server.jar.clone()
-        }).flatten() {
-            println!("Installing server jar");
-
-            let steps = jar.resolve_steps(&self, Environment::Server).await?;
-
-            println!("{steps:#?}");
-
-            self.execute_steps(base, &steps).await?;
-        }
-
-        Ok(())
-    }
-
-    pub async fn action_install_addons(self: Arc<Self>, base: &Path) -> Result<()> {
-        let addons = self.collect_addons().await?;
-        let base = Arc::new(base.to_owned());
-
-        const MAX_CONCURRENT_TASKS: usize = 20;
+pub mod addons;
+pub mod server_jar;
 
-        stream::iter(addons).map(Ok).try_for_each_concurrent(
-            Some(MAX_CONCURRENT_TASKS),
-            move |addon| {
-                let app = self.clone();
-                let base = base.clone();
-                async move {
-                    app.action_install_addon(&base, &addon).await
-                }
-            }
-        ).await?;
+impl App {
+    pub async fn action_build(self: Arc<Self>, base: &Path) -> Result<()> {
+        self.action_install_jar(base).await?;
+        self.clone().action_install_addons(base).await?;
 
-        Ok(())
-    }
+        self.action_generate_script().await?;
 
-    pub async fn action_install_addon(self: Arc<Self>, base: &Path, addon: &Addon) -> Result<()> {
-        let steps = addon.resolve_steps(&self).await?;
-        let dir = base.join(addon.target.as_str());
-        self.execute_steps(&dir, &steps).await?;
         Ok(())
     }
 }

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

@@ -0,0 +1,21 @@
+use std::path::Path;
+
+use anyhow::Result;
+
+use crate::api::{app::App, models::Environment};
+
+impl App {
+    pub async fn action_install_jar(&self, base: &Path) -> Result<()> {
+        if let Some(jar) = self.server.read().await.as_ref().map(|(_, server)| {
+            server.jar.clone()
+        }).flatten() {
+            println!("Installing server jar");
+
+            let steps = jar.resolve_steps(&self, Environment::Server).await?;
+
+            self.execute_steps(base, &steps).await?;
+        }
+
+        Ok(())
+    }
+}

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

@@ -1,8 +1,8 @@
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
 
 use anyhow::Result;
 
-use crate::api::{app::App, models::{markdown::{MarkdownOptions, MarkdownOutput}, metadata::{AddonMetadata, AddonMetadataSource}}};
+use crate::api::{app::App, models::{markdown::MarkdownOptions, metadata::{AddonMetadata, MetadataContainer}}};
 
 impl App {
     pub async fn get_markdown_options(&self) -> Option<MarkdownOptions> {
@@ -13,7 +13,7 @@ impl App {
         }
     }
 
-    pub async fn get_all_metadata(self: Arc<Self>) -> Result<Vec<AddonMetadata>> {
+    pub async fn get_all_addon_metadata(self: Arc<Self>) -> Result<Vec<AddonMetadata>> {
         let addons = self.collect_addons().await?;
 
         let mut metadata = vec![];
@@ -28,18 +28,35 @@ impl App {
         Ok(metadata)
     }
 
-    pub async fn render_markdown_with(&self, metadata: Vec<AddonMetadata>) -> Result<String> {
+    pub async fn get_metadata(self: Arc<Self>) -> Result<MetadataContainer> {
+        let addons = self.get_all_addon_metadata().await?;
+
+        Ok(MetadataContainer {
+            addons
+        })
+    }
+
+    pub async fn render_metadata(&self, metadata: MetadataContainer) -> Result<HashMap<String, String>> {
+        let markdown_options = self.get_markdown_options().await.unwrap_or_default();
+
+        let mut map = HashMap::new();
+
+        map.insert(String::from("addons"), markdown_options.render_addons(metadata.addons));
+
+        Ok(map)
+    }
+
+    pub async fn render_addon_metadata(&self, metadata: Vec<AddonMetadata>) -> Result<String> {
         let markdown_options = self.get_markdown_options().await.unwrap_or_default();
 
-        let table = markdown_options.render(metadata, markdown_options.output_type);
+        let table = markdown_options.table_addons(metadata, markdown_options.output_type);
 
         Ok(table.render(markdown_options.output_type))
     }
 
     pub async fn render_markdown_and_save(self: Arc<Self>) -> Result<()> {
-        let metadata = self.clone().get_all_metadata().await?;
-        let content = self.render_markdown_with(metadata).await?;
-        let options = self.get_markdown_options().await.unwrap_or_default();
+        let metadata = self.clone().get_metadata().await?;
+        let rendered = self.render_metadata(metadata).await?;
 
         // TODO
 

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

@@ -3,8 +3,45 @@ use anyhow::Result;
 use crate::api::{app::App, models::server::Server, utils::script::Shell};
 
 impl App {
-    pub fn get_server_execution_arguments(&self) -> Vec<String> {
-        todo!()
+    pub fn get_args(&self, server: &Server) -> Vec<String> {
+        let (prefix, suffix) = self.get_args_prefix_suffix(server);
+        let exec = self.get_args_exec(server);
+
+        vec![prefix, exec, suffix].concat()
+    }
+
+    pub fn get_args_exec(&self, server: &Server) -> Vec<String> {
+        server.jar.as_ref().map(|s| s.get_exec_arguments()).unwrap_or_default()
+    }
+
+    pub fn get_args_prefix_suffix(&self, server: &Server) -> (Vec<String>, Vec<String>) {
+        let mut prefix = vec![];
+
+        prefix.extend(server.launcher.jvm_args.split_whitespace().map(ToOwned::to_owned));
+
+        // TODO: -Xmx -Xms
+
+        prefix.extend(server.launcher.preset_flags.get_flags());
+
+        if server.launcher.eula_args && server.jar.as_ref().is_some_and(|x| x.flavor().supports_eula_args()) {
+            prefix.push(String::from("-Dcom.mojang.eula.agree=true"));
+        }
+
+        for (key, value) in &server.launcher.properties {
+            let value = serde_json::to_string(value).unwrap();
+
+            prefix.push(format!("-D{key}={value}"));
+        }
+
+        let mut suffix = vec![];
+
+        if server.launcher.nogui && server.jar.as_ref().is_some_and(|x| x.flavor().supports_nogui()) {
+            suffix.push(String::from("--nogui"));
+        }
+
+        suffix.extend(server.launcher.game_args.split_whitespace().map(ToOwned::to_owned));
+
+        (prefix, suffix)
     }
 
     pub fn get_script_lines_for(&self, shell: Shell, server: &Server) -> Vec<String> {
@@ -16,7 +53,7 @@ impl App {
 
         lines.extend(server.launcher.prelaunch.clone());
 
-        todo!();
+        lines.push(self.get_args(server).join(" "));
 
         lines.extend(server.launcher.postlaunch.clone());
 

src/api/app/cache/mod.rs

@@ -4,7 +4,7 @@ use std::{
     path::PathBuf,
 };
 
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
 use serde::de::DeserializeOwned;
 
 use crate::api::step::CacheLocation;
@@ -49,6 +49,8 @@ impl Cache {
             Some(base) => {
                 let fullpath = base.join(path);
 
+                std::fs::create_dir_all(fullpath.parent().ok_or(anyhow!("No parent"))?)?;
+
                 let writer = BufWriter::new(
                     File::create(&fullpath)
                         .context(format!("Creating cache file at: {}", fullpath.display()))?,

src/api/models/addon/addon_type.rs

@@ -30,6 +30,7 @@ pub enum AddonType {
         version: String,
     },
 
+    #[serde(alias = "ghrel")]
     GithubRelease {
         #[serde(alias = "repository")]
         repo: String,

src/api/models/markdown/render.rs

@@ -3,7 +3,11 @@ use crate::api::{models::metadata::AddonMetadata, utils::markdown::{HeaderAlignm
 use super::{MarkdownOptions, MarkdownOutput, MdColumn};
 
 impl MarkdownOptions {
-    pub fn render(&self, list: Vec<AddonMetadata>, output: MarkdownOutput) -> MarkdownTable {
+    pub fn render_addons(&self, list: Vec<AddonMetadata>) -> String {
+        self.table_addons(list, self.output_type).render(self.output_type)
+    }
+
+    pub fn table_addons(&self, list: Vec<AddonMetadata>, output: MarkdownOutput) -> MarkdownTable {
         let mut table = MarkdownTable::new();
 
         for column in &self.columns {

src/api/models/metadata/mod.rs

@@ -1,7 +1,10 @@
+use serde::{Deserialize, Serialize};
+
 mod addon_metadata;
 
 pub use addon_metadata::*;
 
-pub enum MetadataBlock {
-    Addons(Vec<AddonMetadata>),
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct MetadataContainer {
+    pub addons: Vec<AddonMetadata>,
 }

src/api/models/network/mod.rs

@@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize};
 
 pub const NETWORK_TOML: &str = "network.toml";
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub struct Network {
     pub name: String,
 }

src/api/models/server/server_flavor.rs

@@ -33,4 +33,18 @@ impl ServerFlavor {
             ServerFlavor::Proxy => true,
         }
     }
+
+    pub fn supports_nogui(&self) -> bool {
+        match self {
+            ServerFlavor::Proxy => false,
+            _ => true,
+        }
+    }
+
+    pub fn supports_eula_args(&self) -> bool {
+        match self {
+            ServerFlavor::Patched => true,
+            _ => false,
+        }
+    }
 }

src/api/models/server/server_type.rs

@@ -91,6 +91,9 @@ pub enum ServerType {
 
         #[serde(default)]
         flavor: ServerFlavor,
+
+        #[serde(default)]
+        exec: Option<String>,
     },
 }
 
@@ -131,6 +134,18 @@ impl ServerJar {
         }
     }
 
+    pub fn get_exec_arguments(&self) -> Vec<String> {
+        match &self.server_type {
+            ServerType::Forge { .. } => todo!(),
+            ServerType::Custom { exec, .. } => exec.clone()
+                .unwrap_or(String::from("-jar server.jar"))
+                .split_whitespace()
+                .map(ToOwned::to_owned)
+                .collect::<Vec<_>>(),
+            _ => vec![String::from("-jar"), String::from("server.jar")],
+        }
+    }
+
     pub async fn update(&mut self, app: &App) -> Result<bool> {
         match self.server_type.clone() {
             ServerType::Vanilla {  } => Ok(false),
@@ -160,7 +175,7 @@ impl ServerJar {
             ServerType::NeoForge { loader } => todo!(),
             ServerType::Forge { loader } => todo!(),
             ServerType::BuildTools { .. } => Ok(false),
-            ServerType::Custom { inner, flavor } => todo!(),
+            ServerType::Custom { .. } => todo!(),
         }
     }
 }

src/api/sources/github/mod.rs

@@ -47,14 +47,16 @@ impl<'a> GithubAPI<'a> {
             .http_get_with(format!("{}/{url}", self.0.options.api_urls.github), |req| {
                 req.headers(headers)
             })
-            .await?;
+            .await
+            .with_context(|| format!("Github: HTTP GET /{url}"))?;
 
         if response.status() == StatusCode::NOT_MODIFIED {
             Ok(cached_data.unwrap().data)
         } else {
             let etag = response.headers().get("etag").cloned();
 
-            let json: T = response.json().await?;
+            let json: T = response.json().await
+                .with_context(|| format!("Github: JSON decoding: {url}"))?;
 
             if let Some(etag) = etag {
                 self.0.cache.try_write_json(
@@ -96,8 +98,7 @@ impl<'a> GithubAPI<'a> {
             "latest" => releases.first(),
             tag => releases
                 .iter()
-                .find(|r| r.tag_name == tag)
-                .or_else(|| releases.iter().find(|r| r.tag_name.contains(tag))),
+                .find(|r| r.tag_name == tag),
         }
         .ok_or(anyhow!(
             "Github release '{tag}' not found on repository '{repo}'"
@@ -118,9 +119,7 @@ impl<'a> GithubAPI<'a> {
             "" | "first" | "any" => release.assets.first(),
             id => {
                 let id = if id.contains('$') {
-                    id.replace("${version}", &release.tag_name)
-                        .replace("${tag}", &release.tag_name)
-                        .replace("${release}", &release.tag_name)
+                    id.replace("${tag}", release_tag)
                 } else {
                     id.to_owned()
                 };

src/api/sources/github/models.rs

@@ -11,7 +11,7 @@ pub struct GithubRelease {
 pub struct GithubAsset {
     pub url: String,
     pub name: String,
-    pub label: String,
+    pub label: Option<String>,
     pub size: u64,
     pub download_count: u64,
 }