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

package/rust/cli/addon/commands.rs

@@ -0,0 +1,35 @@
+use crate::cli::addon::{
+    install::install_addon, list::list_addons, remove::remove_addon, update::update_addon,
+};
+
+pub async fn handle_install_addon_command(name: String, no_clear_tmp: bool) -> Result<(), String> {
+    if let Err(e) = install_addon(name, no_clear_tmp).await {
+        return Err(format!("Failed to install addon: {}", e));
+    }
+
+    Ok(())
+}
+
+pub async fn handle_list_addon_command() -> Result<(), String> {
+    if let Err(e) = list_addons().await {
+        return Err(format!("Failed to list addons: {}", e));
+    }
+
+    Ok(())
+}
+
+pub async fn handle_remove_addon_command(name: String) -> Result<(), String> {
+    if let Err(e) = remove_addon(name).await {
+        return Err(format!("Failed to remove addon: {}", e));
+    }
+
+    Ok(())
+}
+
+pub async fn handle_update_addon_command(name: String) -> Result<(), String> {
+    if let Err(e) = update_addon(name).await {
+        return Err(format!("Failed to update addon: {}", e));
+    }
+
+    Ok(())
+}

package/rust/cli/addon/download.rs

@@ -0,0 +1,234 @@
+use crate::{
+    cli::addon::{metadata::AddonToDownloadMetadata, utils::ask_api_for_signed_url},
+    config::ops::load_config,
+    web::cdn::download_from_cdn,
+};
+use devalang_core::config::driver::{ProjectConfig, ProjectConfigExt};
+use devalang_types::{AddonType, ProjectConfigBankEntry, ProjectConfigPluginEntry};
+use devalang_utils::{
+    file::extract_zip_safely,
+    logger::{LogLevel, Logger},
+    spinner::start_spinner,
+};
+use std::fs;
+
+pub async fn download_addon(
+    slug: &str,
+    addon_metadata: &AddonToDownloadMetadata,
+) -> Result<(), String> {
+    let logger = Logger::new();
+    let deva_dir = devalang_utils::path::ensure_deva_dir()?;
+
+    let target_dir = match addon_metadata.addon_type {
+        AddonType::Bank => deva_dir.join("banks"),
+        AddonType::Plugin => deva_dir.join("plugins"),
+        AddonType::Preset => deva_dir.join("presets"),
+        AddonType::Template => deva_dir.join("templates"),
+    };
+
+    if !target_dir.exists() {
+        fs::create_dir_all(&target_dir).map_err(|e| {
+            format!(
+                "Failed to create target dir '{}': {}",
+                target_dir.display(),
+                e
+            )
+        })?;
+    }
+
+    let user_provided_publisher = slug.contains('.');
+    let display_name = if user_provided_publisher {
+        format!("{}.{}", addon_metadata.publisher, addon_metadata.name)
+    } else {
+        addon_metadata.name.clone()
+    };
+
+    let archive_path = {
+        let tmp_root = deva_dir.join("tmp");
+        if !tmp_root.exists() {
+            fs::create_dir_all(&tmp_root)
+                .map_err(|e| format!("Failed to create tmp dir '{}': {}", tmp_root.display(), e))?;
+        }
+        tmp_root.join(&display_name).with_extension("tar.gz")
+    };
+
+    if let Some(parent) = archive_path.parent() {
+        if !parent.exists() {
+            fs::create_dir_all(parent)
+                .map_err(|e| format!("Failed to prepare tmp dir '{}': {}", parent.display(), e))?;
+        }
+    }
+
+    let extract_path = target_dir
+        .join(&addon_metadata.publisher)
+        .join(&addon_metadata.name);
+
+    let signed_url = {
+        let spinner =
+            start_spinner(format!("Requesting download link for {}", display_name).as_str());
+        let request = if user_provided_publisher {
+            ask_api_for_signed_url(
+                addon_metadata.addon_type.clone(),
+                addon_metadata.publisher.clone(),
+                &addon_metadata.name,
+            )
+        } else {
+            ask_api_for_signed_url(
+                addon_metadata.addon_type.clone(),
+                String::new(),
+                &addon_metadata.name,
+            )
+        };
+
+        match request.await {
+            Ok(url) => url,
+            Err(err) => {
+                let message = format!("Failed to obtain download link: {}", err);
+                println!("{}", message);
+                return Err(message);
+            }
+        }
+    };
+
+    let config_path = devalang_utils::path::get_devalang_config_path()?;
+    let mut config = load_config(Some(&config_path))
+        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
+
+    if extract_path.exists() {
+        logger.log_message(
+            LogLevel::Info,
+            format!(
+                "Addon '{}' already present at {}",
+                display_name.as_str(),
+                extract_path.display()
+            )
+            .as_str(),
+        );
+
+        if ensure_config_entry(&mut config, addon_metadata) {
+            if let Err(err) = config.write_config(&config) {
+                logger.log_message(
+                    LogLevel::Error,
+                    format!("Failed to write config: {}", err).as_str(),
+                );
+            }
+        }
+
+        if matches!(
+            addon_metadata.addon_type,
+            AddonType::Preset | AddonType::Template
+        ) {
+            logger.log_message(
+                LogLevel::Info,
+                "Presets and templates are not tracked in project config yet.",
+            );
+        }
+
+        return Ok(());
+    }
+
+    let download_spinner = start_spinner("Downloading archive...");
+    match download_from_cdn(&signed_url, &archive_path).await {
+        Ok(_) => println!("Downloaded archive to {}", archive_path.display()),
+        Err(err) => {
+            let message = format!("Failed to download archive: {}", err);
+            println!("{}", message);
+            return Err(message);
+        }
+    }
+
+    let extract_spinner = start_spinner("Extracting archive");
+    match extract_zip_safely(&archive_path, &extract_path) {
+        Ok(_) => println!("Installed at {}", extract_path.display()),
+        Err(err) => {
+            println!("Failed to extract archive: {}", err);
+            return Err(err);
+        }
+    }
+
+    let mut config_updated = false;
+    if ensure_config_entry(&mut config, addon_metadata) {
+        match config.write_config(&config) {
+            Ok(_) => {
+                config_updated = true;
+            }
+            Err(err) => {
+                logger.log_message(
+                    LogLevel::Error,
+                    format!("Failed to write config: {}", err).as_str(),
+                );
+            }
+        }
+    }
+
+    logger.log_message(
+        LogLevel::Info,
+        format!(
+            "Addon '{}' installed at {}",
+            display_name,
+            extract_path.display()
+        )
+        .as_str(),
+    );
+
+    if config_updated {
+        logger.log_message(LogLevel::Info, "Project config updated");
+    } else if matches!(
+        addon_metadata.addon_type,
+        AddonType::Preset | AddonType::Template
+    ) {
+        logger.log_message(
+            LogLevel::Info,
+            "Presets and templates are not tracked in project config yet.",
+        );
+    }
+
+    // Cleanup temporary files used during download/install
+    if let Err(err) = devalang_utils::file::clear_tmp_folder() {
+        logger.log_message(
+            LogLevel::Warning,
+            format!("Failed to clear tmp folder: {}", err).as_str(),
+        );
+    }
+
+    Ok(())
+}
+
+fn ensure_config_entry(
+    config: &mut ProjectConfig,
+    addon_metadata: &AddonToDownloadMetadata,
+) -> bool {
+    match addon_metadata.addon_type {
+        AddonType::Bank => {
+            let dependency_path = format!(
+                "devalang://bank/{}/{}",
+                addon_metadata.publisher, addon_metadata.name
+            );
+            let banks = config.banks.get_or_insert_with(Vec::new);
+            if banks.iter().any(|entry| entry.path == dependency_path) {
+                false
+            } else {
+                banks.push(ProjectConfigBankEntry {
+                    path: dependency_path,
+                });
+                true
+            }
+        }
+        AddonType::Plugin => {
+            let dependency_path = format!(
+                "devalang://plugin/{}/{}",
+                addon_metadata.publisher, addon_metadata.name
+            );
+            let plugins = config.plugins.get_or_insert_with(Vec::new);
+            if plugins.iter().any(|entry| entry.path == dependency_path) {
+                false
+            } else {
+                plugins.push(ProjectConfigPluginEntry {
+                    path: dependency_path,
+                });
+                true
+            }
+        }
+        AddonType::Preset | AddonType::Template => false,
+    }
+}

package/rust/cli/addon/install.rs

@@ -0,0 +1,33 @@
+use devalang_utils::logger::Logger;
+
+use crate::cli::addon::{download::download_addon, metadata::get_addon_from_api};
+
+pub async fn install_addon(slug: String, no_clear_tmp: bool) -> Result<(), String> {
+    let addon_metadata = get_addon_from_api(&slug).await?;
+
+    if let Err(e) = download_addon(&slug, &addon_metadata).await {
+        eprintln!("Failed to download addon '{}': {}", slug, e);
+    }
+
+    let logger = Logger::new();
+    logger.log_message(
+        devalang_utils::logger::LogLevel::Success,
+        &format!(
+            "Successfully installed addon '{}.{}' ({})",
+            addon_metadata.publisher,
+            addon_metadata.name,
+            match addon_metadata.addon_type {
+                devalang_types::AddonType::Bank => "bank",
+                devalang_types::AddonType::Plugin => "plugin",
+                devalang_types::AddonType::Preset => "preset",
+                devalang_types::AddonType::Template => "template",
+            }
+        ),
+    );
+
+    if !no_clear_tmp {
+        let _ = devalang_utils::file::clear_tmp_folder();
+    }
+
+    Ok(())
+}

package/rust/cli/addon/list.rs

@@ -0,0 +1,224 @@
+use devalang_utils::logger::{LogLevel, Logger};
+
+#[derive(Clone)]
+struct InstalledAddon {
+    name: String,
+    addon_type: String,
+}
+
+pub async fn list_addons() -> Result<(), String> {
+    let deva_dir = devalang_utils::path::ensure_deva_dir()?;
+    let banks_dir = deva_dir.join("banks");
+    let plugins_dir = deva_dir.join("plugins");
+    let presets_dir = deva_dir.join("presets");
+    let templates_dir = deva_dir.join("templates");
+
+    let mut installed_addons = Vec::new();
+
+    if banks_dir.exists() {
+        if let Ok(entries) = std::fs::read_dir(&banks_dir) {
+            for entry in entries.flatten() {
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_dir() {
+                        if let Some(name) = entry.file_name().to_str() {
+                            installed_addons.push(InstalledAddon {
+                                name: name.to_string(),
+                                addon_type: "bank".to_string(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if plugins_dir.exists() {
+        if let Ok(entries) = std::fs::read_dir(&plugins_dir) {
+            for entry in entries.flatten() {
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_dir() {
+                        if let Some(name) = entry.file_name().to_str() {
+                            installed_addons.push(InstalledAddon {
+                                name: name.to_string(),
+                                addon_type: "plugin".to_string(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if presets_dir.exists() {
+        if let Ok(entries) = std::fs::read_dir(&presets_dir) {
+            for entry in entries.flatten() {
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_dir() {
+                        if let Some(name) = entry.file_name().to_str() {
+                            installed_addons.push(InstalledAddon {
+                                name: name.to_string(),
+                                addon_type: "preset".to_string(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if templates_dir.exists() {
+        if let Ok(entries) = std::fs::read_dir(&templates_dir) {
+            for entry in entries.flatten() {
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_dir() {
+                        if let Some(name) = entry.file_name().to_str() {
+                            installed_addons.push(InstalledAddon {
+                                name: name.to_string(),
+                                addon_type: "template".to_string(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let logger = Logger::new();
+
+    if installed_addons.is_empty() {
+        logger.log_message(LogLevel::Info, "No addon installed.");
+    } else {
+        let installed_banks = installed_addons.iter().filter(|a| a.addon_type == "bank");
+
+        let installed_plugins = installed_addons.iter().filter(|a| a.addon_type == "plugin");
+
+        let installed_presets = installed_addons.iter().filter(|a| a.addon_type == "preset");
+
+        let installed_templates = installed_addons
+            .iter()
+            .filter(|a| a.addon_type == "template");
+
+        if installed_banks.clone().count() > 0 {
+            let trace: Vec<String> = installed_addons
+                .iter()
+                .map(|a| format!("{}", a.name))
+                .collect();
+            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
+
+            logger.log_message_with_trace(LogLevel::Info, "Installed banks :", trace);
+        }
+
+        if installed_plugins.clone().count() > 0 {
+            let trace: Vec<String> = installed_addons
+                .iter()
+                .map(|a| format!("{}", a.name))
+                .collect();
+            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
+
+            logger.log_message_with_trace(LogLevel::Info, "Installed plugins :", trace);
+        }
+
+        if installed_presets.clone().count() > 0 {
+            let trace: Vec<String> = installed_addons
+                .iter()
+                .map(|a| format!("{}", a.name))
+                .collect();
+            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
+
+            logger.log_message_with_trace(LogLevel::Info, "Installed presets :", trace);
+        }
+
+        if installed_templates.clone().count() > 0 {
+            let trace: Vec<String> = installed_addons
+                .iter()
+                .map(|a| format!("{}", a.name))
+                .collect();
+            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
+
+            logger.log_message_with_trace(LogLevel::Info, "Installed templates :", trace);
+        }
+
+        if let Some(addon_not_in_config) = find_unused_addons(installed_addons.clone()) {
+            let trace: Vec<String> = addon_not_in_config
+                .iter()
+                .map(|a| format!("{} ({})", a.name, a.addon_type))
+                .collect();
+            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
+
+            logger.log_message_with_trace(
+                LogLevel::Warning,
+                "Some addons are installed but not referenced in the .devalang configuration file :",
+                trace,
+            );
+        }
+
+        logger.log_message(
+            LogLevel::Success,
+            format!("Found {} installed addon(s).", installed_addons.len()).as_str(),
+        );
+    }
+
+    Ok(())
+}
+
+fn find_unused_addons(addons: Vec<InstalledAddon>) -> Option<Vec<InstalledAddon>> {
+    let mut unused_addons = Vec::new();
+
+    let config_path = match devalang_utils::path::get_devalang_config_path() {
+        Ok(path) => path,
+        Err(_) => return None,
+    };
+
+    let config = match crate::config::ops::load_config(Some(&config_path)) {
+        Some(cfg) => cfg,
+        None => return None,
+    };
+
+    let mut referenced_addons = Vec::new();
+
+    if let Some(banks) = config.banks {
+        for bank in banks {
+            if let Some(name) = bank.path.strip_prefix("devalang://bank/") {
+                referenced_addons.push((name.to_string(), "bank".to_string()));
+            }
+        }
+    }
+
+    if let Some(plugins) = config.plugins {
+        for plugin in plugins {
+            if let Some(name) = plugin.path.strip_prefix("devalang://plugin/") {
+                referenced_addons.push((name.to_string(), "plugin".to_string()));
+            }
+        }
+    }
+
+    // TODO: Enable when presets and templates are supported in config
+    // if let Some(presets) = config.presets {
+    //     for preset in presets {
+    //         if let Some(name) = preset.path.strip_prefix("devalang://preset/") {
+    //             referenced_addons.push((name.to_string(), "preset".to_string()));
+    //         }
+    //     }
+    // }
+
+    // TODO: Enable when presets and templates are supported in config
+    // if let Some(templates) = config.templates {
+    //     for template in templates {
+    //         if let Some(name) = template.path.strip_prefix("devalang://template/") {
+    //             referenced_addons.push((name.to_string(), "template".to_string()));
+    //         }
+    //     }
+    // }
+
+    for addon in addons {
+        if !referenced_addons.contains(&(addon.name.clone(), addon.addon_type.clone())) {
+            unused_addons.push(addon);
+        }
+    }
+
+    if unused_addons.is_empty() {
+        None
+    } else {
+        Some(unused_addons)
+    }
+}

package/rust/cli/addon/metadata.rs

@@ -0,0 +1,124 @@
+use crate::web::api::get_api_url;
+
+#[derive(Debug, Clone)]
+pub struct AddonToDownloadMetadata {
+    pub name: String,
+    pub publisher: String,
+    pub addon_type: devalang_types::AddonType,
+}
+
+pub async fn get_addon_publisher_from_api(slug: &str) -> Result<String, String> {
+    let api_url = get_api_url();
+
+    let request_url = format!("{}/v1/products/getBySlug/{}", api_url, slug);
+
+    let client: reqwest::Client = reqwest::Client::builder()
+        .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))?;
+
+    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
+            ));
+        }
+    };
+
+    let payload = json.get("payload");
+    let publisher = payload
+        .unwrap_or(&serde_json::Value::Null)
+        .get("publisher")
+        .and_then(|v| v.get("name"))
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown")
+        .to_string();
+
+    Ok(publisher)
+}
+
+pub async fn get_addon_from_api(slug: &str) -> Result<AddonToDownloadMetadata, String> {
+    let api_url = get_api_url();
+
+    let request_url = format!("{}/v1/products/getBySlug/{}", api_url, slug);
+
+    let client: reqwest::Client = reqwest::Client::builder()
+        .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))?;
+
+    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
+            ));
+        }
+    };
+
+    let payload = json.get("payload");
+    let addon_type = payload
+        .unwrap_or(&serde_json::Value::Null)
+        .get("addon")
+        .unwrap_or(&serde_json::Value::Null)
+        .get("addon_type")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown");
+
+    let addon_type_enum = match addon_type {
+        "bank" => devalang_types::AddonType::Bank,
+        "plugin" => devalang_types::AddonType::Plugin,
+        "preset" => devalang_types::AddonType::Preset,
+        "template" => devalang_types::AddonType::Template,
+        _ => {
+            return Err(format!("Unknown addon type: {}", addon_type));
+        }
+    };
+
+    let addon_metadata = AddonToDownloadMetadata {
+        name: payload
+            .unwrap_or(&serde_json::Value::Null)
+            .get("addon")
+            .unwrap_or(&serde_json::Value::Null)
+            .get("name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("unknown")
+            .to_string(),
+        publisher: payload
+            .unwrap_or(&serde_json::Value::Null)
+            .get("publisher")
+            .unwrap_or(&serde_json::Value::Null)
+            .get("name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("unknown")
+            .to_string(),
+        addon_type: addon_type_enum,
+    };
+
+    Ok(addon_metadata)
+}

package/rust/cli/addon/mod.rs

@@ -0,0 +1,8 @@
+pub mod commands;
+pub mod download;
+pub mod install;
+pub mod list;
+pub mod metadata;
+pub mod remove;
+pub mod update;
+pub mod utils;