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

package/rust/cli/install/addon.rs

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

@@ -2,7 +2,9 @@ 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,
@@ -39,15 +41,32 @@ pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {
 
     // Add the bank to the config
     let config_path = path_utils::get_devalang_config_path()?;
-    let _config = load_config(Some(&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);
+    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))?;
 
-    // TODO: Add the bank to the config
+    // 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

@@ -1,35 +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(())
-}
+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

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

package/rust/cli/install/plugin.rs

@@ -1,61 +1,80 @@
-use crate::{
-    config::ops::load_config,
-    web::cdn::{download_from_cdn, get_cdn_url},
-};
-use devalang_utils::path as path_utils;
-use std::{fs, path::Path};
-
-pub async fn install_plugin(name: &str, target_dir: &Path) -> Result<(), String> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/plugin/{}/download", cdn_url, name);
-
-    let plugin_dir = target_dir.join("plugins");
-
-    // Ensure .deva/tmp exists and build archive path
-    let deva_dir = path_utils::ensure_deva_dir()?;
-    let tmp_dir = deva_dir.join("tmp");
-    if !tmp_dir.exists() {
-        fs::create_dir_all(&tmp_dir)
-            .map_err(|e| format!("Failed to create tmp dir '{}': {}", tmp_dir.display(), e))?;
-    }
-
-    let archive_path = tmp_dir.join(format!("{}.devaplugin", name));
-    let extract_path = plugin_dir.join(name);
-
-    if extract_path.exists() {
-        println!(
-            "Plugin '{}' already exists at '{}'. Skipping install.",
-            name,
-            extract_path.display()
-        );
-        return Ok(());
-    }
-
-    download_from_cdn(&url, &archive_path)
-        .await
-        .map_err(|e| format!("Failed to download: {}", e))?;
-
-    // Add the plugin to the config: locate project root from target_dir
-    let project_root = path_utils::find_project_root_from(target_dir)
-        .ok_or_else(|| "Failed to determine project root from target_dir".to_string())?;
-
-    let config_path = project_root.join(path_utils::DEVALANG_CONFIG);
-    if !config_path.exists() {
-        return Err(format!(
-            "Config file not found at '{}'. Please run 'devalang init' before adding an addon",
-            config_path.display()
-        ));
-    }
-
-    let _config = load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    let _dependency_path = &format!("devalang://plugin/{}", name);
-
-    devalang_utils::file::extract_zip_safely(&archive_path, &extract_path)
-        .map_err(|e| format!("Failed to extract: {}", e))?;
-
-    // TODO: Add the plugin to the config
-
-    Ok(())
-}
+use crate::{
+    config::ops::load_config,
+    web::cdn::{download_from_cdn, get_cdn_url},
+};
+use devalang_core::config::driver::ProjectConfigExt;
+use devalang_types::ProjectConfigPluginEntry;
+use devalang_utils::path as path_utils;
+use std::{fs, path::Path};
+
+pub async fn install_plugin(name: &str, target_dir: &Path) -> Result<(), String> {
+    let cdn_url = get_cdn_url();
+    let url = format!("{}/plugin/{}/download", cdn_url, name);
+
+    let plugin_dir = target_dir.join("plugins");
+
+    // Ensure .deva/tmp exists and build archive path
+    let deva_dir = path_utils::ensure_deva_dir()?;
+    let tmp_dir = deva_dir.join("tmp");
+    if !tmp_dir.exists() {
+        fs::create_dir_all(&tmp_dir)
+            .map_err(|e| format!("Failed to create tmp dir '{}': {}", tmp_dir.display(), e))?;
+    }
+
+    let archive_path = tmp_dir.join(format!("{}.devaplugin", name));
+    let extract_path = plugin_dir.join(name);
+
+    if extract_path.exists() {
+        println!(
+            "Plugin '{}' already exists at '{}'. Skipping install.",
+            name,
+            extract_path.display()
+        );
+        return Ok(());
+    }
+
+    download_from_cdn(&url, &archive_path)
+        .await
+        .map_err(|e| format!("Failed to download: {}", e))?;
+
+    // Add the plugin to the config: locate project root from target_dir
+    let project_root = path_utils::find_project_root_from(target_dir)
+        .ok_or_else(|| "Failed to determine project root from target_dir".to_string())?;
+
+    let config_path = project_root.join(path_utils::DEVALANG_CONFIG);
+    if !config_path.exists() {
+        return Err(format!(
+            "Config file not found at '{}'. Please run 'devalang init' before adding an addon",
+            config_path.display()
+        ));
+    }
+
+    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://plugin/{}", name);
+
+    devalang_utils::file::extract_zip_safely(&archive_path, &extract_path)
+        .map_err(|e| format!("Failed to extract: {}", e))?;
+
+    // Add the plugin to the config if not already present
+    if config.plugins.is_none() {
+        config.plugins = Some(Vec::new());
+    }
+
+    if let Some(plugins) = config.plugins.as_mut() {
+        let exists = plugins.iter().any(|p| p.path == dependency_path);
+        if !exists {
+            plugins.push(ProjectConfigPluginEntry {
+                path: dependency_path.clone(),
+                version: None,
+            });
+
+            if let Err(e) = config.write_config(&config) {
+                eprintln!("Warning: failed to write config: {}", e);
+            }
+        }
+    }
+
+    Ok(())
+}