@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

package/rust/cli/discover/config.rs

@@ -0,0 +1,111 @@
+use devalang_core::config::driver::ProjectConfigExt;
+use devalang_types::{AddonWithMetadata, ProjectConfigBankEntry, ProjectConfigPluginEntry};
+use devalang_utils::path as path_utils;
+
+pub async fn add_addons_to_config(addons: Vec<AddonWithMetadata>) -> Result<(), String> {
+    let config_path = path_utils::get_devalang_config_path()?;
+    let mut config = crate::config::ops::load_config(Some(&config_path))
+        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
+
+    for addon in addons {
+        let addon_path_as_devalang_protocol = format!(
+            "devalang://{}/{}.{}",
+            addon.addon_type, addon.metadata.author, addon.metadata.name
+        );
+
+        match addon.addon_type.as_str() {
+            "bank" => {
+                if config.banks.is_none() {
+                    config.banks = Some(Vec::new());
+                }
+
+                let banks = config.banks.as_mut().unwrap();
+
+                let exists = banks
+                    .iter()
+                    .any(|b| b.path == addon_path_as_devalang_protocol);
+                if exists {
+                    println!("Bank '{}' already in config", addon.name);
+                    continue;
+                }
+
+                banks.push(ProjectConfigBankEntry {
+                    path: addon_path_as_devalang_protocol,
+                    version: Some(addon.metadata.version.clone()),
+                });
+            }
+
+            "plugin" => {
+                if config.plugins.is_none() {
+                    config.plugins = Some(Vec::new());
+                }
+
+                let plugins = config.plugins.as_mut().unwrap();
+
+                let exists = plugins
+                    .iter()
+                    .any(|p| p.path == addon_path_as_devalang_protocol);
+                if exists {
+                    println!("Plugin '{}' already in config", addon.name);
+                    continue;
+                }
+
+                plugins.push(ProjectConfigPluginEntry {
+                    path: addon_path_as_devalang_protocol,
+                    version: Some(addon.metadata.version.clone()),
+                });
+            }
+
+            // "preset" => {
+            //     if config.presets.is_none() {
+            //         config.presets = Some(Vec::new());
+            //     }
+
+            //     let presets = config.presets.as_mut().unwrap();
+
+            //     let exists = presets.iter().any(|p| p.path == addon_path_as_deva_protocol);
+            //     if exists {
+            //         println!("Preset '{}' already in config", addon.name);
+            //         continue;
+            //     }
+
+            //     presets.push(ProjectConfigPresetEntry {
+            //         path: addon_path_as_deva_protocol,
+            //         version: Some(addon.metadata.version.clone()),
+            //     });
+            // }
+
+            // "template" => {
+            //     if config.templates.is_none() {
+            //         config.templates = Some(Vec::new());
+            //     }
+
+            //     let templates = config.templates.as_mut().unwrap();
+
+            //     let exists = templates.iter().any(|t| t.path == addon_path_as_deva_protocol);
+            //     if exists {
+            //         println!("Template '{}' already in config", addon.name);
+            //         continue;
+            //     }
+
+            //     templates.push(ProjectConfigTemplateEntry {
+            //         path: addon_path_as_deva_protocol,
+            //         version: Some(addon.metadata.version.clone()),
+            //     });
+            // }
+            _ => {
+                println!(
+                    "Unknown addon type '{}' for addon '{}'",
+                    addon.addon_type, addon.name
+                );
+            }
+        }
+    }
+
+    // Update config with new addons
+    if let Err(e) = config.write_config(&config) {
+        return Err(format!("Failed to write config: {}", e));
+    }
+
+    Ok(())
+}

package/rust/cli/discover/fs.rs

@@ -0,0 +1,19 @@
+use std::{fs, io, path::Path};
+
+pub fn copy_dir_all(src: &Path, dst: &Path) -> Result<(), io::Error> {
+    if !dst.exists() {
+        fs::create_dir_all(dst)?;
+    }
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        let from = entry.path();
+        let to = dst.join(entry.file_name());
+        if ty.is_dir() {
+            copy_dir_all(&from, &to)?;
+        } else {
+            fs::copy(&from, &to)?;
+        }
+    }
+    Ok(())
+}

package/rust/cli/discover/install.rs

@@ -0,0 +1,103 @@
+use devalang_types::{AddonMetadata, AddonWithMetadata, DiscoveredAddon};
+use devalang_utils::path as path_utils;
+
+pub async fn install_selected_addons(
+    addons: Vec<DiscoveredAddon>,
+) -> Result<Vec<AddonWithMetadata>, String> {
+    let mut addons_enriched = Vec::new();
+
+    let tmp_dir = path_utils::ensure_deva_dir()?.join("tmp");
+
+    for addon in addons {
+        std::fs::create_dir_all(tmp_dir.join(&addon.name))
+            .map_err(|e| format!("Failed to create directory for addon {}: {}", addon.name, e))?;
+
+        let addon_path = tmp_dir.join(&addon.name);
+        devalang_utils::file::extract_zip_safely(&addon.path, &addon_path)
+            .map_err(|e| format!("Failed to extract addon {}: {}", addon.name, e))?;
+
+        let base = path_utils::ensure_deva_dir()?;
+        let target_addon_dir = match addon.addon_type.as_str() {
+            "bank" => base.join("banks"),
+            "plugin" => base.join("plugins"),
+            "preset" => base.join("presets"),
+            "template" => base.join("templates"),
+            _ => {
+                return Err(format!("Unknown addon type for addon {}", addon.name));
+            }
+        };
+
+        std::fs::create_dir_all(&target_addon_dir).map_err(|e| {
+            format!(
+                "Failed to create target directory for addon {}: {}",
+                addon.name, e
+            )
+        })?;
+
+        let target_addon_path_dir = target_addon_dir.join(&addon.name);
+        if target_addon_path_dir.exists() {
+            println!(
+                "Target addon directory {} already exists",
+                target_addon_path_dir.display()
+            );
+            continue;
+        }
+
+        if let Err(e) = std::fs::rename(&addon_path, &target_addon_path_dir) {
+            crate::cli::discover::fs::copy_dir_all(&addon_path, &target_addon_path_dir).map_err(
+                |err| {
+                    format!(
+                        "Failed to move addon {}: {} (rename error: {})",
+                        addon.name, err, e
+                    )
+                },
+            )?;
+            let _ = std::fs::remove_dir_all(&addon_path);
+        }
+
+        let addon_metadata_filename = match addon.addon_type.as_str() {
+            "bank" => "bank.toml",
+            "plugin" => "plugin.toml",
+            "preset" => "preset.toml",
+            "template" => "template.toml",
+            _ => {
+                return Err(format!("Unknown addon type for addon {}", addon.name));
+            }
+        };
+
+        let addon_metadata_path = target_addon_path_dir.join(addon_metadata_filename);
+        let addon_metadata_content = std::fs::read_to_string(&addon_metadata_path)
+            .map_err(|e| format!("Failed to read metadata for addon {}: {}", addon.name, e))?;
+
+        let parsed_meta = crate::cli::discover::metadata::parse_metadata_file(
+            &addon.addon_type,
+            &addon_metadata_content,
+        )
+        .unwrap_or(AddonMetadata {
+            name: addon.name.clone(),
+            author: "unknown".to_string(),
+            version: "".to_string(),
+            description: "".to_string(),
+            access: "".to_string(),
+        });
+
+        addons_enriched.push(AddonWithMetadata {
+            name: addon.name.clone(),
+            path: addon.path.clone().to_string_lossy().to_string(),
+            addon_type: addon.addon_type.clone(),
+            metadata: parsed_meta,
+        });
+
+        if let Err(e) = std::fs::remove_file(&addon.path) {
+            eprintln!(
+                "Failed to remove zipped file for addon {}: {}",
+                addon.name, e
+            );
+        }
+    }
+
+    // Best-effort cleanup of temporary extraction directory
+    let _ = std::fs::remove_dir_all(&tmp_dir);
+
+    Ok(addons_enriched)
+}

package/rust/cli/discover/metadata.rs

@@ -0,0 +1,48 @@
+use devalang_types::AddonMetadata;
+use toml::Value;
+
+pub fn parse_metadata_file(addon_type: &str, metadata_content: &str) -> Option<AddonMetadata> {
+    let parsed = metadata_content.parse::<Value>().ok()?;
+
+    let table = (match addon_type {
+        "bank" => parsed.get("bank"),
+        "plugin" => parsed.get("plugin"),
+        "preset" => parsed.get("preset"),
+        "template" => parsed.get("template"),
+        _ => None,
+    })?;
+
+    let name = table
+        .get("name")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let version = table
+        .get("version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let description = table
+        .get("description")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let author = table
+        .get("author")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown")
+        .to_string();
+    let access = table
+        .get("access")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+
+    Some(AddonMetadata {
+        name,
+        author,
+        version,
+        description,
+        access,
+    })
+}

package/rust/cli/discover/mod.rs

@@ -0,0 +1,5 @@
+pub mod commands;
+pub mod config;
+pub mod fs;
+pub mod install;
+pub mod metadata;

package/rust/cli/{init.rs → init/commands.rs}

@@ -1,29 +1,35 @@
-use std::{ fs, path::Path };
-use include_dir::{ include_dir, Dir };
-use crate::{ cli::template::get_available_templates, utils::file::copy_dir_recursive };
+use crate::cli::template::commands::get_available_templates;
+use devalang_utils::file::copy_dir_recursive;
+use include_dir::{Dir, include_dir};
+use std::{fs, path::Path};
 
 #[cfg(feature = "cli")]
-use inquire::{ Select, Confirm };
+use inquire::{Confirm, Select};
 
 static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
 
 #[cfg(feature = "cli")]
 pub fn handle_init_command(name: Option<String>, template: Option<String>) {
     let current_dir = std::env::current_dir().unwrap();
-    let project_name = name
-        .clone()
-        .unwrap_or_else(|| {
-            current_dir.file_name().unwrap_or_default().to_string_lossy().to_string()
-        });
+    let project_name = name.clone().unwrap_or_else(|| {
+        current_dir
+            .file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .to_string()
+    });
 
     // Select a template if not provided
     let selected_template = template.unwrap_or_else(|| {
-        Select::new("Select a template for your project:", get_available_templates())
-            .prompt()
-            .unwrap_or_else(|_| {
-                eprintln!("No template selected. Exiting...");
-                std::process::exit(1);
-            })
+        Select::new(
+            "Select a template for your project:",
+            get_available_templates(),
+        )
+        .prompt()
+        .unwrap_or_else(|_| {
+            eprintln!("No template selected. Exiting...");
+            std::process::exit(1);
+        })
     });
 
     if selected_template.is_empty() {
@@ -34,12 +40,11 @@ pub fn handle_init_command(name: Option<String>, template: Option<String>) {
     if name.is_none() {
         // Case of initialization in the current directory
         if fs::read_dir(&current_dir).unwrap().next().is_some() {
-            let confirm = Confirm::new(
-                "The current directory is not empty. Do you want to continue?"
-            )
-                .with_default(false)
-                .prompt()
-                .unwrap_or(false);
+            let confirm =
+                Confirm::new("The current directory is not empty. Do you want to continue?")
+                    .with_default(false)
+                    .prompt()
+                    .unwrap_or(false);
 
             if !confirm {
                 eprintln!("Operation cancelled by the user.");
@@ -65,7 +70,11 @@ pub fn handle_init_command(name: Option<String>, template: Option<String>) {
         fs::create_dir_all(&target_path).expect("Error creating project directory");
 
         scaffold_project_current_dir(&target_path, selected_template);
-        println!("✅ Initialized '{}' project in: {}", project_name, target_path.display());
+        println!(
+            "✅ Initialized '{}' project in: {}",
+            project_name,
+            target_path.display()
+        );
     }
 }
 
@@ -75,5 +84,5 @@ fn scaffold_project_current_dir(path: &Path, template: String) {
         std::process::exit(1);
     });
 
-    copy_dir_recursive(template_dir, path, &template_dir.path());
+    copy_dir_recursive(template_dir, path, template_dir.path());
 }

package/rust/cli/init/mod.rs

@@ -0,0 +1 @@
+pub mod commands;

package/rust/cli/install/addon.rs

@@ -0,0 +1,118 @@
+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)
+    }
+}

package/rust/cli/install/bank.rs

@@ -0,0 +1,72 @@
+use crate::{
+    cli::install::addon::ask_api_for_signed_url, config::ops::load_config,
+    web::cdn::download_from_cdn,
+};
+use devalang_core::config::driver::ProjectConfigExt;
+use devalang_types::AddonType;
+use devalang_types::ProjectConfigBankEntry;
+use devalang_utils::{
+    logger::{LogLevel, Logger},
+    path as path_utils,
+};
+use std::path::Path;
+
+pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {
+    let logger = Logger::new();
+
+    let signed_url = ask_api_for_signed_url(AddonType::Bank, name).await?;
+
+    let bank_dir = target_dir.join("banks");
+    let archive_path = path_utils::ensure_deva_dir()?
+        .join("tmp")
+        .join(format!("{}.devabank", name));
+    let extract_path = bank_dir.join(name);
+
+    download_from_cdn(&signed_url, &archive_path)
+        .await
+        .map_err(|e| format!("Failed to download: {}", e))?;
+
+    if extract_path.exists() {
+        logger.log_message(
+            LogLevel::Warning,
+            &format!(
+                "Bank '{}' already exists at '{}'. Skipping install.",
+                name,
+                extract_path.display()
+            ),
+        );
+
+        return Ok(());
+    }
+
+    // Add the bank to the config
+    let config_path = path_utils::get_devalang_config_path()?;
+    let mut config = load_config(Some(&config_path))
+        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
+
+    let dependency_path = format!("devalang://bank/{}", name);
+
+    devalang_utils::file::extract_zip_safely(&archive_path, &extract_path)
+        .map_err(|e| format!("Failed to extract: {}", e))?;
+
+    // Add the bank to the config if not already present
+    if config.banks.is_none() {
+        config.banks = Some(Vec::new());
+    }
+
+    if let Some(banks) = config.banks.as_mut() {
+        let exists = banks.iter().any(|b| b.path == dependency_path);
+        if !exists {
+            banks.push(ProjectConfigBankEntry {
+                path: dependency_path.clone(),
+                version: None,
+            });
+
+            if let Err(e) = config.write_config(&config) {
+                eprintln!("Warning: failed to write config: {}", e);
+            }
+        }
+    }
+
+    Ok(())
+}

package/rust/cli/install/commands.rs

@@ -0,0 +1,35 @@
+use crate::cli::install::addon::install_addon;
+#[cfg(feature = "cli")]
+use devalang_types::AddonType;
+use devalang_utils::path as path_utils;
+
+/// Handles the installation command for a given addon type and name.
+#[cfg(feature = "cli")]
+pub async fn handle_install_command(name: String, addon_type: AddonType) -> Result<(), String> {
+    use devalang_utils::{
+        logger::{LogLevel, Logger},
+        spinner::start_spinner,
+    };
+
+    let logger = Logger::new();
+    let deva_dir = path_utils::ensure_deva_dir()?;
+
+    let spinner = start_spinner("Installing...");
+
+    if let Err(e) = install_addon(addon_type.clone(), name.as_str(), &deva_dir).await {
+        spinner.finish_and_clear();
+        logger.log_message_with_trace(
+            LogLevel::Error,
+            &format!("Error installing {:?} '{}'", addon_type, name),
+            vec![&e],
+        );
+    } else {
+        spinner.finish_and_clear();
+        logger.log_message(
+            LogLevel::Success,
+            &format!("{:?} '{}' installed successfully!", addon_type, name),
+        );
+    }
+
+    Ok(())
+}

package/rust/cli/install/mod.rs

@@ -0,0 +1,4 @@
+pub mod addon;
+pub mod bank;
+pub mod commands;
+pub mod plugin;