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

package/rust/cli/addon/update.rs

@@ -0,0 +1,305 @@
+use crate::config::ops::load_config;
+use crate::{
+    cli::addon::{
+        download::download_addon,
+        metadata::{get_addon_from_api, get_addon_publisher_from_api},
+    },
+    web::cdn::get_cdn_url,
+};
+use devalang_core::config::driver::ProjectConfigExt;
+use devalang_types::AddonType;
+use devalang_utils::path as path_utils;
+use std::fs;
+use toml::Value as TomlValue;
+
+#[derive(serde::Deserialize)]
+pub struct AddonVersion {
+    pub version: String,
+}
+
+async fn fetch_latest_version(
+    addon_type: AddonType,
+    addon_name: String,
+) -> Result<AddonVersion, Box<dyn std::error::Error>> {
+    let cdn_url = get_cdn_url();
+
+    let addon_type = match addon_type {
+        AddonType::Bank => "bank",
+        AddonType::Plugin => "plugin",
+        AddonType::Preset => "preset",
+        AddonType::Template => "template",
+    };
+
+    let publisher_identifier = get_addon_publisher_from_api(&addon_name)
+        .await
+        .unwrap_or("unknown".to_string());
+
+    let url = format!(
+        "{}/{}/{}/{}/version",
+        cdn_url, addon_type, publisher_identifier, addon_name
+    );
+
+    let response = reqwest::get(url).await?;
+
+    if !response.status().is_success() {
+        return Err(format!("❌ Failed to fetch version: HTTP {}", response.status()).into());
+    }
+
+    let bytes = response.bytes().await?;
+
+    let version: AddonVersion = serde_json::from_slice(&bytes)?;
+
+    Ok(version)
+}
+
+pub async fn update_addon(slug: String) -> Result<(), String> {
+    let addon_metadata = get_addon_from_api(&slug).await?;
+    let deva_dir = path_utils::ensure_deva_dir()?;
+
+    // Represent the addon as "<publisher>.<addon>" for user-visible names
+    let publisher_and_name = format!("{}.{}", addon_metadata.publisher, addon_metadata.name);
+
+    match addon_metadata.addon_type {
+        devalang_types::AddonType::Bank => {
+            match fetch_latest_version(
+                addon_metadata.addon_type.clone(),
+                addon_metadata.name.clone(),
+            )
+            .await
+            {
+                Ok(latest) => {
+                    // Determine local version from bank.toml if available
+                    let local_bank_path = deva_dir
+                        .join("banks")
+                        .join(&addon_metadata.publisher)
+                        .join(&addon_metadata.name);
+                    let local_version = if local_bank_path.exists() {
+                        let bank_toml = local_bank_path.join("bank.toml");
+                        if bank_toml.exists() {
+                            if let Ok(content) = fs::read_to_string(&bank_toml) {
+                                if let Ok(parsed) =
+                                    toml::from_str::<devalang_types::BankFile>(&content)
+                                {
+                                    parsed.bank.version
+                                } else {
+                                    String::new()
+                                }
+                            } else {
+                                String::new()
+                            }
+                        } else {
+                            String::new()
+                        }
+                    } else {
+                        String::new()
+                    };
+
+                    if local_version != latest.version {
+                        println!(
+                            "Updating bank '{}' from '{}' to '{}'...",
+                            publisher_and_name, local_version, latest.version
+                        );
+
+                        // remove existing folder if present
+                        let bank_dir = deva_dir
+                            .join("banks")
+                            .join(&addon_metadata.publisher)
+                            .join(&addon_metadata.name);
+                        if bank_dir.exists() {
+                            fs::remove_dir_all(&bank_dir)
+                                .map_err(|e| format!("Failed to remove old bank files: {}", e))?;
+                        }
+
+                        // download new (use publisher.addon as the external identifier)
+                        download_addon(&publisher_and_name, &addon_metadata).await?;
+
+                        // update config version when present
+                        if let Ok(config_path) = path_utils::get_devalang_config_path() {
+                            if let Some(mut config) = load_config(Some(&config_path)) {
+                                if let Some(banks) = config.banks.as_mut() {
+                                    for bank in banks.iter_mut() {
+                                        let name_in_path = bank
+                                            .path
+                                            .strip_prefix("devalang://bank/")
+                                            .unwrap_or(&bank.path);
+                                    }
+
+                                    if let Err(e) = config.write_config(&config) {
+                                        eprintln!("Warning: failed to write updated config: {}", e);
+                                    }
+                                }
+                            }
+                        }
+
+                        println!(
+                            "✅ Bank '{}' updated to version '{}'",
+                            publisher_and_name, latest.version
+                        );
+                    } else {
+                        println!(
+                            "Bank '{}' is already up-to-date (version {})",
+                            publisher_and_name, latest.version
+                        );
+                    }
+                }
+                Err(e) => {
+                    return Err(format!(
+                        "Failed to fetch latest version for bank '{}': {}",
+                        publisher_and_name, e
+                    ));
+                }
+            }
+        }
+
+        devalang_types::AddonType::Plugin => {
+            // Try to fetch latest version via CDN API; if available compare, otherwise fallback to redownload
+            match fetch_latest_version(
+                addon_metadata.addon_type.clone(),
+                addon_metadata.name.clone(),
+            )
+            .await
+            {
+                Ok(latest) => {
+                    // Determine local plugin version by reading plugin.toml from preferred or fallback layout
+                    let preferred = deva_dir.join("plugins").join(format!(
+                        "{}/{}",
+                        addon_metadata.publisher, addon_metadata.name
+                    ));
+                    let fallback = deva_dir
+                        .join("plugins")
+                        .join(&addon_metadata.publisher)
+                        .join(&addon_metadata.name);
+
+                    let mut local_version = String::new();
+                    for candidate in [&preferred, &fallback] {
+                        let toml_path = candidate.join("plugin.toml");
+                        if toml_path.exists() {
+                            if let Ok(content) = fs::read_to_string(&toml_path) {
+                                if let Ok(value) = toml::from_str::<TomlValue>(&content) {
+                                    if let Some(v) = value
+                                        .get("plugin")
+                                        .and_then(|p| p.get("version"))
+                                        .and_then(|s| s.as_str())
+                                    {
+                                        local_version = v.to_string();
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    }
+
+                    if local_version != latest.version {
+                        println!(
+                            "Updating plugin '{}' from '{}' to '{}'...",
+                            publisher_and_name, local_version, latest.version
+                        );
+
+                        // remove any existing layout
+                        if preferred.exists() {
+                            fs::remove_dir_all(&preferred)
+                                .map_err(|e| format!("Failed to remove old plugin files: {}", e))?;
+                        }
+                        if fallback.exists() {
+                            fs::remove_dir_all(&fallback)
+                                .map_err(|e| format!("Failed to remove old plugin files: {}", e))?;
+                        }
+
+                        // download new
+                        download_addon(&publisher_and_name, &addon_metadata).await?;
+
+                        // update config version when present
+                        if let Ok(config_path) = path_utils::get_devalang_config_path() {
+                            if let Some(mut config) = load_config(Some(&config_path)) {
+                                if let Some(plugins) = config.plugins.as_mut() {
+                                    for p in plugins.iter_mut() {
+                                        let name_in_path = p
+                                            .path
+                                            .strip_prefix("devalang://plugin/")
+                                            .unwrap_or(&p.path);
+                                    }
+
+                                    if let Err(e) = config.write_config(&config) {
+                                        eprintln!("Warning: failed to write updated config: {}", e);
+                                    }
+                                }
+                            }
+                        }
+
+                        println!(
+                            "✅ Plugin '{}' updated to version '{}'",
+                            publisher_and_name, latest.version
+                        );
+                    } else {
+                        println!(
+                            "Plugin '{}' is already up-to-date (version {})",
+                            publisher_and_name, latest.version
+                        );
+                    }
+                }
+                Err(_) => {
+                    // Fallback: redownload everything
+                    println!(
+                        "No version info for plugin '{}', redownloading to ensure latest.",
+                        publisher_and_name
+                    );
+
+                    let plugin_dir = deva_dir
+                        .join("plugins")
+                        .join(&addon_metadata.publisher)
+                        .join(&addon_metadata.name);
+                    if plugin_dir.exists() {
+                        fs::remove_dir_all(&plugin_dir)
+                            .map_err(|e| format!("Failed to remove old plugin files: {}", e))?;
+                    }
+
+                    download_addon(&publisher_and_name, &addon_metadata).await?;
+
+                    // clear version in config (unknown)
+                    if let Ok(config_path) = path_utils::get_devalang_config_path() {
+                        if let Some(mut config) = load_config(Some(&config_path)) {
+                            if let Some(plugins) = config.plugins.as_mut() {
+                                for p in plugins.iter_mut() {
+                                    let name_in_path = p
+                                        .path
+                                        .strip_prefix("devalang://plugin/")
+                                        .unwrap_or(&p.path);
+                                }
+
+                                if let Err(e) = config.write_config(&config) {
+                                    eprintln!("Warning: failed to write updated config: {}", e);
+                                }
+                            }
+                        }
+                    }
+
+                    println!("✅ Plugin '{}' updated", publisher_and_name);
+                }
+            }
+        }
+
+        devalang_types::AddonType::Preset | devalang_types::AddonType::Template => {
+            println!(
+                "Update for presets/templates is not yet implemented; reinstalling to be safe."
+            );
+            let target_dir = match addon_metadata.addon_type {
+                devalang_types::AddonType::Preset => deva_dir.join("presets"),
+                _ => deva_dir.join("templates"),
+            };
+
+            let candidate = target_dir
+                .join(&addon_metadata.publisher)
+                .join(&addon_metadata.name);
+            if candidate.exists() {
+                fs::remove_dir_all(&candidate)
+                    .map_err(|e| format!("Failed to remove old files: {}", e))?;
+            }
+
+            // use publisher.addon representation for user-facing messaging
+            download_addon(&publisher_and_name, &addon_metadata).await?;
+            println!("✅ Addon '{}' updated (reinstalled)", publisher_and_name);
+        }
+    }
+
+    Ok(())
+}

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

@@ -1,26 +1,12 @@
-use crate::{
-    cli::install::{bank::install_bank, plugin::install_plugin},
-    config::settings::get_user_config,
-    web::api::get_api_url,
-};
+use crate::{config::settings::get_user_config, web::forge::get_forge_api_url};
 use devalang_types::AddonType;
-use std::path::Path;
 
-pub async fn install_addon(
+pub async fn ask_api_for_signed_url(
     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();
+    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;
@@ -38,31 +24,36 @@ pub async fn ask_api_for_signed_url(addon_type: AddonType, slug: &str) -> Result
         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 {
-        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
-        )
+        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 {
-        format!(
-            "{}/v1/assets/url?type={}&slug={}",
-            api_url,
-            match addon_type {
-                AddonType::Bank => "bank",
-                AddonType::Plugin => "plugin",
-                AddonType::Preset => "preset",
-                AddonType::Template => "template",
-            },
-            slug
-        )
+        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();

package/rust/cli/build/commands.rs

@@ -1,103 +1,153 @@
-use crate::{config::driver::ProjectConfig, core::utils::path::find_entry_file};
-use devalang_utils::logger::{LogLevel, Logger};
-use devalang_utils::watcher::watch_directory;
-
-#[cfg(feature = "cli")]
-pub fn handle_build_command(
-    config: Option<ProjectConfig>,
-    entry: Option<String>,
-    output: Option<String>,
-    watch: bool,
-    debug: bool,
-    compress: bool,
-) -> Result<(), String> {
-    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();
-
-    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(),
-            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(),
-                debug,
-                compress,
-            );
-        })
-        .unwrap();
-    } else {
-        let res =
-            crate::cli::build::process::process_build(entry_file, fetched_output, 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(())
+}

package/rust/cli/build/mod.rs

@@ -1,2 +1,2 @@
-pub mod commands;
-pub mod process;
+pub mod commands;
+pub mod process;