Remove the concept of [custom], just specify entrypoint if not using godot/unity

Author: franzwarning

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "wavedash"
-version = "0.1.64"
+version = "0.1.65"
 edition = "2021"
 authors = ["Wavedash Team"]
 description = "Cross-platform CLI tool for uploading game projects to wavedash.com"

Cargo.toml

@@ -48,8 +48,8 @@ struct TempCredsResponse {
 
 async fn get_temp_credentials(
     game_id: &str,
-    engine: &str,
-    engine_version: &str,
+    engine: Option<&str>,
+    engine_version: Option<&str>,
     entrypoint: Option<&str>,
     entrypoint_params: Option<serde_json::Value>,
     message: Option<&str>,
@@ -65,12 +65,17 @@ async fn get_temp_credentials(
     );
 
     let mut request_body = serde_json::json!({
-        "engine": engine,
-        "engineVersion": engine_version,
         "buildSizeBytes": build_size_bytes
     });
 
-    // Add entrypoint if provided (for custom engine)
+    if let Some(eng) = engine {
+        request_body["engine"] = serde_json::json!(eng);
+    }
+
+    if let Some(ver) = engine_version {
+        request_body["engineVersion"] = serde_json::json!(ver);
+    }
+
     if let Some(ep) = entrypoint {
         request_body["entrypoint"] = serde_json::json!(ep);
     }
@@ -194,8 +199,8 @@ pub async fn handle_build_push(config_path: PathBuf, verbose: bool, message: Opt
     let engine_kind = wavedash_config.engine_type()?;
     let creds = get_temp_credentials(
         &wavedash_config.game_id,
-        engine_kind.as_config_key(),
-        wavedash_config.engine_version()?,
+        engine_kind.map(|e| e.as_label()),
+        wavedash_config.engine_version(),
         wavedash_config.entrypoint(),
         wavedash_config.executable_entrypoint_params(),
         message.as_deref(),

src/builds.rs

@@ -96,12 +96,6 @@ pub struct UnitySection {
     pub version: String,
 }
 
-#[derive(Debug, Deserialize)]
-pub struct CustomSection {
-    pub version: String,
-    pub entrypoint: String,
-}
-
 #[derive(Debug, Deserialize)]
 pub struct JsDosSection {
     pub version: String,
@@ -127,9 +121,6 @@ pub struct WavedashConfig {
     #[serde(rename = "unity")]
     pub unity: Option<UnitySection>,
 
-    #[serde(rename = "custom")]
-    pub custom: Option<CustomSection>,
-
     #[serde(rename = "jsdos")]
     pub jsdos: Option<JsDosSection>,
 
@@ -141,27 +132,15 @@ pub struct WavedashConfig {
 pub enum EngineKind {
     Godot,
     Unity,
-    Custom,
     JsDos,
     Ruffle,
 }
 
 impl EngineKind {
-    pub fn as_config_key(&self) -> &'static str {
-        match self {
-            EngineKind::Godot => "godot",
-            EngineKind::Unity => "unity",
-            EngineKind::Custom => "custom",
-            EngineKind::JsDos => "jsdos",
-            EngineKind::Ruffle => "ruffle",
-        }
-    }
-
     pub fn as_label(&self) -> &'static str {
         match self {
             EngineKind::Godot => "GODOT",
             EngineKind::Unity => "UNITY",
-            EngineKind::Custom => "CUSTOM",
             EngineKind::JsDos => "JSDOS",
             EngineKind::Ruffle => "RUFFLE",
         }
@@ -184,11 +163,10 @@ impl WavedashConfig {
         Ok(config)
     }
 
-    pub fn engine_type(&self) -> Result<EngineKind> {
+    pub fn engine_type(&self) -> Result<Option<EngineKind>> {
         let engines: Vec<EngineKind> = [
             self.godot.is_some().then_some(EngineKind::Godot),
             self.unity.is_some().then_some(EngineKind::Unity),
-            self.custom.is_some().then_some(EngineKind::Custom),
             self.jsdos.is_some().then_some(EngineKind::JsDos),
             self.ruffle.is_some().then_some(EngineKind::Ruffle),
         ]
@@ -197,36 +175,34 @@ impl WavedashConfig {
         .collect();
 
         match engines.len() {
-            1 => Ok(engines[0]),
-            0 => anyhow::bail!(
-                "Config must have exactly one engine section: [godot], [unity], [custom], [jsdos], or [ruffle]"
-            ),
+            0 => Ok(None),
+            1 => Ok(Some(engines[0])),
             _ => anyhow::bail!(
-                "Config must have exactly one engine section: [godot], [unity], [custom], [jsdos], or [ruffle]"
+                "Config must have at most one engine section: [godot], [unity], [jsdos], or [ruffle]"
             ),
         }
     }
 
-    pub fn engine_version(&self) -> Result<&str> {
+    pub fn engine_version(&self) -> Option<&str> {
         if let Some(ref godot) = self.godot {
-            Ok(&godot.version)
+            Some(&godot.version)
         } else if let Some(ref unity) = self.unity {
-            Ok(&unity.version)
-        } else if let Some(ref custom) = self.custom {
-            Ok(&custom.version)
+            Some(&unity.version)
         } else if let Some(ref jsdos) = self.jsdos {
-            Ok(&jsdos.version)
+            Some(&jsdos.version)
         } else if let Some(ref ruffle) = self.ruffle {
-            Ok(&ruffle.version)
+            Some(&ruffle.version)
         } else {
-            anyhow::bail!("No engine section found")
+            None
         }
     }
 
+    /// Returns the entrypoint when no engine block is present (defaults to "index.html").
     pub fn entrypoint(&self) -> Option<&str> {
-        self.custom
-            .as_ref()
-            .map(|c| c.entrypoint.as_str())
+        match self.engine_type() {
+            Ok(None) => Some("index.html"),
+            _ => None,
+        }
     }
 
     /// For JSDOS/Ruffle engines, returns the entrypointParams (executable + optional loader_url)

src/config.rs

@@ -42,8 +42,8 @@ struct CreateLocalBuildResponse {
 
 async fn create_local_build(
     game_id: &str,
-    engine: &str,
-    engine_version: &str,
+    engine: Option<&str>,
+    engine_version: Option<&str>,
     entrypoint: Option<&str>,
     entrypoint_params: Option<&serde_json::Value>,
     api_key: &str,
@@ -56,10 +56,15 @@ async fn create_local_build(
         api_host, game_id
     );
 
-    let mut request_body = serde_json::json!({
-        "engine": engine,
-        "engineVersion": engine_version
-    });
+    let mut request_body = serde_json::json!({});
+
+    if let Some(eng) = engine {
+        request_body["engine"] = serde_json::json!(eng);
+    }
+
+    if let Some(ver) = engine_version {
+        request_body["engineVersion"] = serde_json::json!(ver);
+    }
 
     if let Some(ep) = entrypoint {
         request_body["entrypoint"] = serde_json::json!(ep);
@@ -115,36 +120,32 @@ pub async fn handle_dev(config_path: Option<PathBuf>, verbose: bool, no_open: bo
     }
 
     let engine_kind = wavedash_config.engine_type()?;
-    let engine_label = engine_kind.as_label();
-
-    let entrypoint = if matches!(engine_kind, EngineKind::Custom) {
-        Some(
-            wavedash_config
-                .entrypoint()
-                .ok_or_else(|| anyhow::anyhow!("Engine config requires an entrypoint"))?
-                .to_string(),
-        )
-    } else {
-        None
-    };
+
+    let entrypoint = wavedash_config.entrypoint().map(|s| s.to_string());
 
     // Validate required files exist in upload directory
     FileStaging::prepare(&upload_dir, &wavedash_config)?;
 
     let html_entrypoint = locate_html_entrypoint(&upload_dir);
-    let engine_version = wavedash_config.engine_version()?;
+    let engine_version = wavedash_config.engine_version();
     let entrypoint_params = match engine_kind {
-        EngineKind::Godot | EngineKind::Unity => {
+        Some(EngineKind::Godot | EngineKind::Unity) => {
+            let engine_label = engine_kind.unwrap().as_label();
             let html_path = html_entrypoint.as_deref().ok_or_else(|| {
                 anyhow::anyhow!(
                     "No HTML file found in upload_dir; required for {} builds",
                     engine_label
                 )
             })?;
-            Some(fetch_entrypoint_params(engine_label, engine_version, html_path).await?)
+            let ver = engine_version.ok_or_else(|| {
+                anyhow::anyhow!("{} engine requires a version", engine_label)
+            })?;
+            Some(fetch_entrypoint_params(engine_label, ver, html_path).await?)
+        }
+        Some(EngineKind::JsDos | EngineKind::Ruffle) => {
+            wavedash_config.executable_entrypoint_params()
         }
-        EngineKind::JsDos | EngineKind::Ruffle => wavedash_config.executable_entrypoint_params(),
-        EngineKind::Custom => None,
+        None => None,
     };
 
     let (rustls_config, cert_path, _key_path) = load_or_create_certificates().await?;
@@ -168,7 +169,7 @@ pub async fn handle_dev(config_path: Option<PathBuf>, verbose: bool, no_open: bo
 
     let local_build = create_local_build(
         &wavedash_config.game_id,
-        engine_label,
+        engine_kind.map(|e| e.as_label()),
         engine_version,
         entrypoint.as_deref(),
         entrypoint_params.as_ref(),

src/dev/mod.rs

@@ -12,8 +12,17 @@ impl FileStaging {
         upload_dir: &Path,
         wavedash_config: &WavedashConfig,
     ) -> Result<Self> {
-        // Validate entrypoint exists in the upload directory (for custom engine)
+        // Validate entrypoint exists and is an HTML file
         if let Some(entrypoint_str) = wavedash_config.entrypoint() {
+            // Entrypoint must be an HTML file
+            let lower = entrypoint_str.to_ascii_lowercase();
+            if !lower.ends_with(".html") && !lower.ends_with(".htm") {
+                anyhow::bail!(
+                    "Entrypoint '{}' must be an HTML file (ending in .html or .htm).",
+                    entrypoint_str,
+                );
+            }
+
             let entrypoint_path = upload_dir.join(entrypoint_str);
             if !entrypoint_path.exists() {
                 anyhow::bail!(