@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.18

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

@@ -1,87 +1,88 @@
-use crate::{cli::template::get_available_templates, utils::file::copy_dir_recursive};
-use include_dir::{Dir, include_dir};
-use std::{fs, path::Path};
-
-#[cfg(feature = "cli")]
-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()
-    });
-
-    // 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);
-        })
-    });
-
-    if selected_template.is_empty() {
-        eprintln!("Template cannot be empty.");
-        std::process::exit(1);
-    }
-
-    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);
-
-            if !confirm {
-                eprintln!("Operation cancelled by the user.");
-                std::process::exit(0);
-            }
-        }
-
-        scaffold_project_current_dir(current_dir.as_path(), selected_template);
-        println!(
-            "✅ Initialized '{}' project in current directory: {}",
-            project_name,
-            current_dir.display()
-        );
-    } else {
-        // Case of initialization in a new directory
-        let target_path = current_dir.join(&project_name);
-
-        if target_path.exists() {
-            eprintln!("❌ A folder named '{}' already exists.", project_name);
-            std::process::exit(1);
-        }
-
-        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()
-        );
-    }
-}
-
-fn scaffold_project_current_dir(path: &Path, template: String) {
-    let template_dir = TEMPLATES_DIR.get_dir(&template).unwrap_or_else(|| {
-        eprintln!("❌ The template '{}' doesn't exist.", template);
-        std::process::exit(1);
-    });
-
-    copy_dir_recursive(template_dir, path, &template_dir.path());
-}
+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::{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()
+    });
+
+    // 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);
+        })
+    });
+
+    if selected_template.is_empty() {
+        eprintln!("Template cannot be empty.");
+        std::process::exit(1);
+    }
+
+    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);
+
+            if !confirm {
+                eprintln!("Operation cancelled by the user.");
+                std::process::exit(0);
+            }
+        }
+
+        scaffold_project_current_dir(current_dir.as_path(), selected_template);
+        println!(
+            "✅ Initialized '{}' project in current directory: {}",
+            project_name,
+            current_dir.display()
+        );
+    } else {
+        // Case of initialization in a new directory
+        let target_path = current_dir.join(&project_name);
+
+        if target_path.exists() {
+            eprintln!("❌ A folder named '{}' already exists.", project_name);
+            std::process::exit(1);
+        }
+
+        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()
+        );
+    }
+}
+
+fn scaffold_project_current_dir(path: &Path, template: String) {
+    let template_dir = TEMPLATES_DIR.get_dir(&template).unwrap_or_else(|| {
+        eprintln!("❌ The template '{}' doesn't exist.", template);
+        std::process::exit(1);
+    });
+
+    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,126 @@
+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::Logger;
+    use devalang_utils::logger::LogLevel;
+
+    // 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,53 @@
+use crate::{
+    cli::install::addon::ask_api_for_signed_url, config::ops::load_config,
+    web::cdn::download_from_cdn,
+};
+use devalang_types::AddonType;
+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 _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))?;
+
+    // TODO: Add the bank to the config
+
+    Ok(())
+}

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

@@ -1,22 +1,22 @@
-use crate::installer::addon::{AddonType, install_addon};
+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 crate::utils::{
+    use devalang_utils::{
         logger::{LogLevel, Logger},
-        spinner::with_spinner,
+        spinner::start_spinner,
     };
-    use std::{thread, time::Duration};
 
     let logger = Logger::new();
-    let deva_dir = std::path::Path::new("./.deva/");
+    let deva_dir = path_utils::ensure_deva_dir()?;
 
-    let spinner = with_spinner("Installing...", || {
-        thread::sleep(Duration::from_millis(800));
-    });
+    let spinner = start_spinner("Installing...");
 
-    if let Err(e) = install_addon(addon_type.clone(), name.as_str(), deva_dir).await {
+    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,

package/rust/{installer → cli/install}/mod.rs

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

package/rust/cli/install/plugin.rs

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

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

@@ -1,7 +1,6 @@
-use crate::common::sso::get_sso_url;
-use crate::config::settings::set_user_config_string;
+use crate::config::settings::set_user_config_value;
+use crate::web::sso::get_sso_url;
 use std::str::FromStr;
-use std::{thread, time::Duration};
 use tiny_http::Header;
 use tiny_http::{Response, Server};
 use webbrowser;
@@ -10,9 +9,9 @@ use webbrowser;
 /// This function initiates the login process by opening the browser and waiting for the callback.
 #[cfg(feature = "cli")]
 pub async fn handle_login_command() -> Result<(), String> {
-    use crate::utils::logger::LogLevel;
-    use crate::utils::logger::Logger;
-    use crate::utils::spinner::with_spinner;
+    use devalang_utils::logger::LogLevel;
+    use devalang_utils::logger::Logger;
+    use devalang_utils::spinner::start_spinner;
 
     let logger = Logger::new();
 
@@ -49,9 +48,7 @@ pub async fn handle_login_command() -> Result<(), String> {
 
     let server = Server::http(format!("127.0.0.1:{}", listener_port)).unwrap();
 
-    let spinner = with_spinner("Waiting for authentication...", || {
-        thread::sleep(Duration::from_millis(800));
-    });
+    let spinner = start_spinner("Waiting for authentication...");
 
     for request in server.incoming_requests() {
         let query = request.url().to_string();
@@ -59,7 +56,7 @@ pub async fn handle_login_command() -> Result<(), String> {
             if query.contains("session=") || query.contains("error=") {
                 let token = query.split("session=").nth(1).unwrap_or("").to_string();
 
-                if token.len() > 0 {
+                if !token.is_empty() {
                     let response_html = r#"
                         <html>
                             <body>
@@ -123,5 +120,5 @@ pub async fn handle_login_command() -> Result<(), String> {
 
 /// Save the session token to a file in the user's home directory
 fn save_token(token: &str) {
-    set_user_config_string("session", token.to_string());
+    set_user_config_value("session", serde_json::Value::String(token.to_string()));
 }

package/rust/cli/login/mod.rs

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

package/rust/cli/mod.rs

@@ -1,11 +1,11 @@
-pub mod driver;
-
 pub mod bank;
 pub mod build;
 pub mod check;
+pub mod discover;
 pub mod init;
 pub mod install;
 pub mod login;
+pub mod parser;
 pub mod play;
 pub mod telemetry;
 pub mod template;

package/rust/cli/{driver.rs → parser.rs}

@@ -1,10 +1,8 @@
-use crate::utils::version::get_version;
 use clap::{Parser, Subcommand};
 
 #[derive(Parser)]
 #[command(name = "devalang")]
 #[command(author = "Devaloop")]
-#[command(version = get_version())]
 #[command(about = "🦊 Devalang – A programming language for music and sound.")]
 pub struct Cli {
     #[arg(long, global = true)]
@@ -25,6 +23,8 @@ pub enum TelemetryCommand {
 
 #[derive(Subcommand)]
 pub enum InstallCommand {
+    /// Installs a template.
+    Template { name: String },
     /// Installs a bank.
     Bank { name: String },
     /// Installs a plugin.
@@ -259,12 +259,17 @@ pub enum Commands {
     /// - `template` - Installs a template.
     /// - `bank` - Installs a bank.
     /// - `plugin` - Installs a plugin.
+    /// - `preset` - Installs a preset.
     ///
     Install {
         #[command(subcommand)]
         command: InstallCommand,
     },
 
+    /// Discover available local addons for Devalang.
+    ///
+    Discover {},
+
     /// Manage banks for Devalang projects.
     ///
     /// ### Subcommands