@devaloop/devalang 0.0.1-beta.2 → 0.0.1-beta.3

package/rust/cli/{install/addon.rs → addon/utils.rs}

@@ -1,118 +1,109 @@
-use crate::{
-    cli::install::{bank::install_bank, plugin::install_plugin},
-    config::settings::get_user_config,
-    web::api::get_api_url,
-};
-use devalang_types::AddonType;
-use std::path::Path;
-
-pub async fn install_addon(
-    addon_type: AddonType,
-    name: &str,
-    target_dir: &Path,
-) -> Result<(), String> {
-    match addon_type {
-        AddonType::Bank => install_bank(name, target_dir).await,
-        AddonType::Plugin => install_plugin(name, target_dir).await,
-        AddonType::Preset => Err("Preset installation not implemented".into()),
-        AddonType::Template => Err("Template installation not implemented".into()),
-    }
-}
-
-pub async fn ask_api_for_signed_url(addon_type: AddonType, slug: &str) -> Result<String, String> {
-    let api_url = get_api_url();
-
-    use devalang_utils::logger::LogLevel;
-    use devalang_utils::logger::Logger;
-
-    // Require an authenticated user for addon installation: token must be present and non-empty
-    let stored_token_opt = get_user_config().and_then(|cfg| {
-        let t = cfg.session.clone();
-        if t.trim().is_empty() { None } else { Some(t) }
-    });
-
-    if stored_token_opt.is_none() {
-        let logger = Logger::new();
-        let msg = "Authentication required — run `devalang login` to authenticate";
-        logger.log_message(LogLevel::Error, msg);
-        return Err("Authentication required: run 'devalang login' to authenticate".to_string());
-    }
-
-    let request_url = if let Some(token) = &stored_token_opt {
-        format!(
-            "{}/v1/assets/url?type={}&slug={}&token={}",
-            api_url,
-            match addon_type {
-                AddonType::Bank => "bank",
-                AddonType::Plugin => "plugin",
-                AddonType::Preset => "preset",
-                AddonType::Template => "template",
-            },
-            slug,
-            token
-        )
-    } else {
-        format!(
-            "{}/v1/assets/url?type={}&slug={}",
-            api_url,
-            match addon_type {
-                AddonType::Bank => "bank",
-                AddonType::Plugin => "plugin",
-                AddonType::Preset => "preset",
-                AddonType::Template => "template",
-            },
-            slug
-        )
-    };
-
-    let mut headers = reqwest::header::HeaderMap::new();
-    if let Some(token) = stored_token_opt {
-        headers.insert(
-            "Authorization",
-            format!("Bearer {}", token).parse().unwrap(),
-        );
-    }
-
-    let client: reqwest::Client = reqwest::Client::builder()
-        .default_headers(headers)
-        .build()
-        .map_err(|_| "Failed to build HTTP client".to_string())?;
-
-    let resp = client
-        .get(&request_url)
-        .send()
-        .await
-        .map_err(|e| format!("Failed to receive response: {}", e))?;
-
-    let status = resp.status();
-    let body_text = resp
-        .text()
-        .await
-        .map_err(|e| format!("Failed to read response body: {}", e))?;
-
-    // Try to parse JSON; if parsing fails, return body for diagnostics
-    let json: serde_json::Value = match serde_json::from_str(&body_text) {
-        Ok(v) => v,
-        Err(_) => {
-            return Err(format!(
-                "Invalid JSON response (status {}): {}",
-                status, body_text
-            ));
-        }
-    };
-
-    // Extract payload.url safely
-    let signed_url_opt = json
-        .get("payload")
-        .and_then(|p| p.get("url"))
-        .and_then(|u| u.as_str())
-        .map(|s| s.to_string());
-
-    if let Some(signed_url) = signed_url_opt {
-        Ok(signed_url)
-    } else {
-        // Provide detailed diagnostics to help user understand why it's null
-        let err_msg = format!("API returned no URL (status {}): {}", status, body_text);
-        Err(err_msg)
-    }
-}
+use crate::{config::settings::get_user_config, web::forge::get_forge_api_url};
+use devalang_types::AddonType;
+
+pub async fn ask_api_for_signed_url(
+    addon_type: AddonType,
+    publisher: String,
+    slug: &str,
+) -> Result<String, String> {
+    let forge_api_url = get_forge_api_url();
+
+    use devalang_utils::logger::LogLevel;
+    use devalang_utils::logger::Logger;
+
+    // Require an authenticated user for addon installation: token must be present and non-empty
+    let stored_token_opt = get_user_config().and_then(|cfg| {
+        let t = cfg.session.clone();
+        if t.trim().is_empty() { None } else { Some(t) }
+    });
+
+    if stored_token_opt.is_none() {
+        let logger = Logger::new();
+        let msg = "Authentication required — run `devalang login` to authenticate";
+        logger.log_message(LogLevel::Error, msg);
+        return Err("Authentication required: run 'devalang login' to authenticate".to_string());
+    }
+
+    // Build request URL. If publisher is empty, omit the publisher param so the API
+    // can resolve publisher by addon name itself (server-side lookup).
+    let kind = match addon_type {
+        AddonType::Bank => "bank",
+        AddonType::Plugin => "plugin",
+        AddonType::Preset => "preset",
+        AddonType::Template => "template",
+    };
+
+    let request_url = if let Some(token) = &stored_token_opt {
+        if publisher.trim().is_empty() {
+            format!(
+                "{}/v1/addon/url?type={}&slug={}&token={}",
+                forge_api_url, kind, slug, token
+            )
+        } else {
+            format!(
+                "{}/v1/addon/url?type={}&publisher={}&slug={}&token={}",
+                forge_api_url, kind, publisher, slug, token
+            )
+        }
+    } else {
+        if publisher.trim().is_empty() {
+            format!("{}/v1/addon/url?type={}&slug={}", forge_api_url, kind, slug)
+        } else {
+            format!(
+                "{}/v1/addon/url?type={}&publisher={}&slug={}",
+                forge_api_url, kind, publisher, slug
+            )
+        }
+    };
+
+    let mut headers = reqwest::header::HeaderMap::new();
+    if let Some(token) = stored_token_opt {
+        headers.insert(
+            "Authorization",
+            format!("Bearer {}", token).parse().unwrap(),
+        );
+    }
+
+    let client: reqwest::Client = reqwest::Client::builder()
+        .default_headers(headers)
+        .build()
+        .map_err(|_| "Failed to build HTTP client".to_string())?;
+
+    let resp = client
+        .get(&request_url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to receive response: {}", e))?;
+
+    let status = resp.status();
+    let body_text = resp
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read response body: {}", e))?;
+
+    // Try to parse JSON; if parsing fails, return body for diagnostics
+    let json: serde_json::Value = match serde_json::from_str(&body_text) {
+        Ok(v) => v,
+        Err(_) => {
+            return Err(format!(
+                "Invalid JSON response (status {}): {}",
+                status, body_text
+            ));
+        }
+    };
+
+    // Extract payload.url safely
+    let signed_url_opt = json
+        .get("payload")
+        .and_then(|p| p.get("url"))
+        .and_then(|u| u.as_str())
+        .map(|s| s.to_string());
+
+    if let Some(signed_url) = signed_url_opt {
+        Ok(signed_url)
+    } else {
+        // Provide detailed diagnostics to help user understand why it's null
+        let err_msg = format!("API returned no URL (status {}): {}", status, body_text);
+        Err(err_msg)
+    }
+}

package/rust/cli/build/commands.rs

@@ -1,153 +1,153 @@
-use crate::config::driver::ProjectConfig;
-use devalang_utils::logger::{LogLevel, Logger};
-use devalang_utils::path::find_entry_file;
-use devalang_utils::watcher::watch_directory;
-
-#[cfg(feature = "cli")]
-pub fn handle_build_command(
-    config: Option<ProjectConfig>,
-    entry: Option<String>,
-    output: Option<String>,
-    output_format: Vec<crate::cli::parser::OutputFormat>,
-    audio_format: crate::cli::parser::AudioFormat,
-    sample_rate: u32,
-    watch: bool,
-    debug: bool,
-    compress: bool,
-) -> Result<(), String> {
-    // determine fetched values from config or CLI
-    let fetched_entry = if entry.is_none() {
-        config
-            .as_ref()
-            .and_then(|c| c.defaults.entry.clone())
-            .unwrap_or_default()
-    } else {
-        entry.clone().unwrap_or_default()
-    };
-
-    let fetched_output = if output.is_none() {
-        config
-            .as_ref()
-            .and_then(|c| c.defaults.output.clone())
-            .unwrap_or_default()
-    } else {
-        output.clone().unwrap_or_default()
-    };
-
-    let fetched_watch = if watch {
-        watch
-    } else {
-        config
-            .as_ref()
-            .and_then(|c| c.defaults.watch)
-            .unwrap_or(false)
-    };
-
-    let logger = Logger::new();
-
-    // Determine final audio_format: prefer CLI, else config default if present
-    let mut final_audio_format = audio_format;
-    if let Some(cfg) = config.as_ref() {
-        if let Some(af) = cfg.defaults.audio_format.as_ref() {
-            // Only override if CLI provided an empty/placeholder — clap provides a default, so we only override when CLI wasn't explicit (rare).
-            // We'll accept values: "wav16", "wav24", "wav32" (case-insensitive)
-            let af_low = af.to_lowercase();
-            final_audio_format = match af_low.as_str() {
-                "wav24" => crate::cli::parser::AudioFormat::Wav24,
-                "wav32" => crate::cli::parser::AudioFormat::Wav32,
-                _ => crate::cli::parser::AudioFormat::Wav16,
-            };
-        }
-    }
-
-    // Determine final output_format: prefer CLI vector, else config default list
-    let mut final_output_format: Vec<crate::cli::parser::OutputFormat> = output_format.clone();
-    if final_output_format.is_empty() {
-        if let Some(cfg) = config.as_ref() {
-            if let Some(ofs) = cfg.defaults.output_format.as_ref() {
-                for s in ofs {
-                    match s.to_lowercase().as_str() {
-                        "mid" | "midi" => {
-                            final_output_format.push(crate::cli::parser::OutputFormat::Mid);
-                        }
-                        _ => final_output_format.push(crate::cli::parser::OutputFormat::Wav),
-                    }
-                }
-            }
-        }
-    }
-
-    if fetched_entry.is_empty() {
-        logger.log_message(
-            LogLevel::Error,
-            "Entry path is not specified. Please provide a valid entry path.",
-        );
-        return Err("missing entry path".to_string());
-    }
-    if fetched_output.is_empty() {
-        logger.log_message(
-            LogLevel::Error,
-            "Output directory is not specified. Please provide a valid output directory.",
-        );
-        return Err("missing output directory".to_string());
-    }
-
-    let entry_file = match find_entry_file(&fetched_entry) {
-        Some(p) => p,
-        None => {
-            logger.log_message(
-                LogLevel::Error,
-                &format!("❌ index.deva not found in directory: {}", fetched_entry),
-            );
-            return Err("index.deva not found".to_string());
-        }
-    };
-
-    // SECTION Begin build
-    if fetched_watch {
-        let _ = crate::cli::build::process::process_build(
-            entry_file.clone(),
-            fetched_output.clone(),
-            final_output_format.clone(),
-            final_audio_format,
-            sample_rate,
-            debug,
-            compress,
-        );
-
-        logger.log_message(
-            LogLevel::Watcher,
-            &format!("Watching for changes in '{}'...", fetched_entry),
-        );
-
-        watch_directory(entry_file.clone(), move || {
-            logger.log_message(LogLevel::Watcher, "Detected changes, re-building...");
-
-            let _ = crate::cli::build::process::process_build(
-                entry_file.clone(),
-                fetched_output.clone(),
-                final_output_format.clone(),
-                final_audio_format,
-                sample_rate,
-                debug,
-                compress,
-            );
-        })
-        .unwrap();
-    } else {
-        let res = crate::cli::build::process::process_build(
-            entry_file,
-            fetched_output,
-            final_output_format,
-            final_audio_format,
-            sample_rate,
-            debug,
-            compress,
-        );
-        if let Err(e) = res {
-            return Err(e);
-        }
-    }
-
-    Ok(())
-}
+use crate::config::driver::ProjectConfig;
+use devalang_utils::logger::{LogLevel, Logger};
+use devalang_utils::path::find_entry_file;
+use devalang_utils::watcher::watch_directory;
+
+#[cfg(feature = "cli")]
+pub fn handle_build_command(
+    config: Option<ProjectConfig>,
+    entry: Option<String>,
+    output: Option<String>,
+    output_format: Vec<crate::cli::parser::OutputFormat>,
+    audio_format: crate::cli::parser::AudioFormat,
+    sample_rate: u32,
+    watch: bool,
+    debug: bool,
+    compress: bool,
+) -> Result<(), String> {
+    // determine fetched values from config or CLI
+    let fetched_entry = if entry.is_none() {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.entry.clone())
+            .unwrap_or_default()
+    } else {
+        entry.clone().unwrap_or_default()
+    };
+
+    let fetched_output = if output.is_none() {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.output.clone())
+            .unwrap_or_default()
+    } else {
+        output.clone().unwrap_or_default()
+    };
+
+    let fetched_watch = if watch {
+        watch
+    } else {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.watch)
+            .unwrap_or(false)
+    };
+
+    let logger = Logger::new();
+
+    // Determine final audio_format: prefer CLI, else config default if present
+    let mut final_audio_format = audio_format;
+    if let Some(cfg) = config.as_ref() {
+        if let Some(af) = cfg.defaults.audio_format.as_ref() {
+            // Only override if CLI provided an empty/placeholder — clap provides a default, so we only override when CLI wasn't explicit (rare).
+            // We'll accept values: "wav16", "wav24", "wav32" (case-insensitive)
+            let af_low = af.to_lowercase();
+            final_audio_format = match af_low.as_str() {
+                "wav24" => crate::cli::parser::AudioFormat::Wav24,
+                "wav32" => crate::cli::parser::AudioFormat::Wav32,
+                _ => crate::cli::parser::AudioFormat::Wav16,
+            };
+        }
+    }
+
+    // Determine final output_format: prefer CLI vector, else config default list
+    let mut final_output_format: Vec<crate::cli::parser::OutputFormat> = output_format.clone();
+    if final_output_format.is_empty() {
+        if let Some(cfg) = config.as_ref() {
+            if let Some(ofs) = cfg.defaults.output_format.as_ref() {
+                for s in ofs {
+                    match s.to_lowercase().as_str() {
+                        "mid" | "midi" => {
+                            final_output_format.push(crate::cli::parser::OutputFormat::Mid);
+                        }
+                        _ => final_output_format.push(crate::cli::parser::OutputFormat::Wav),
+                    }
+                }
+            }
+        }
+    }
+
+    if fetched_entry.is_empty() {
+        logger.log_message(
+            LogLevel::Error,
+            "Entry path is not specified. Please provide a valid entry path.",
+        );
+        return Err("missing entry path".to_string());
+    }
+    if fetched_output.is_empty() {
+        logger.log_message(
+            LogLevel::Error,
+            "Output directory is not specified. Please provide a valid output directory.",
+        );
+        return Err("missing output directory".to_string());
+    }
+
+    let entry_file = match find_entry_file(&fetched_entry) {
+        Some(p) => p,
+        None => {
+            logger.log_message(
+                LogLevel::Error,
+                &format!("❌ index.deva not found in directory: {}", fetched_entry),
+            );
+            return Err("index.deva not found".to_string());
+        }
+    };
+
+    // SECTION Begin build
+    if fetched_watch {
+        let _ = crate::cli::build::process::process_build(
+            entry_file.clone(),
+            fetched_output.clone(),
+            final_output_format.clone(),
+            final_audio_format,
+            sample_rate,
+            debug,
+            compress,
+        );
+
+        logger.log_message(
+            LogLevel::Watcher,
+            &format!("Watching for changes in '{}'...", fetched_entry),
+        );
+
+        watch_directory(entry_file.clone(), move || {
+            logger.log_message(LogLevel::Watcher, "Detected changes, re-building...");
+
+            let _ = crate::cli::build::process::process_build(
+                entry_file.clone(),
+                fetched_output.clone(),
+                final_output_format.clone(),
+                final_audio_format,
+                sample_rate,
+                debug,
+                compress,
+            );
+        })
+        .unwrap();
+    } else {
+        let res = crate::cli::build::process::process_build(
+            entry_file,
+            fetched_output,
+            final_output_format,
+            final_audio_format,
+            sample_rate,
+            debug,
+            compress,
+        );
+        if let Err(e) = res {
+            return Err(e);
+        }
+    }
+
+    Ok(())
+}