@devaloop/devalang 0.0.1-alpha.12 → 0.0.1-alpha.14

package/rust/installer/addon.rs

@@ -0,0 +1,80 @@
+use std::path::Path;
+use crate::{
+    common::{ api::get_api_url },
+    installer::{ bank::install_bank, plugin::install_plugin },
+};
+use dirs::home_dir;
+
+#[derive(Debug, Clone)]
+pub enum AddonType {
+    Bank,
+    Plugin,
+    Preset,
+}
+
+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()),
+    }
+}
+
+pub async fn ask_api_for_signed_url(addon_type: AddonType, slug: &str) -> Result<String, String> {
+    let api_url = get_api_url();
+
+    let mut stored_token_path = home_dir().unwrap();
+    stored_token_path.push(".devalang");
+    stored_token_path.push("session_token.json");
+
+    let stored_token = std::fs::read_to_string(&stored_token_path).unwrap_or_default();
+
+    let request_url = format!(
+        "{}/v1/assets/url?type={}&slug={}&token={}",
+        api_url,
+        match addon_type {
+            AddonType::Bank => "bank",
+            AddonType::Plugin => "plugin",
+            AddonType::Preset => "preset",
+        },
+        slug,
+        stored_token
+    );
+
+    let mut headers = reqwest::header::HeaderMap::new();
+
+    headers.insert("Authorization", format!("Bearer {}", stored_token).parse().unwrap());
+
+    let client: reqwest::Client = reqwest::Client
+        ::builder()
+        .default_headers(headers)
+        .build()
+        .map_err(|_| "Failed to build HTTP client".to_string())?;
+
+    let req = client
+        .get(&request_url)
+        .send().await
+        .map_err(|_| "Failed to receive response".to_string())?;
+
+    let response_body: serde_json::Value = req
+        .json().await
+        .map_err(|_| "Failed to read response body".to_string())?;
+
+    let signed_url: String = serde_json
+        ::from_value(
+            response_body
+                .get("payload")
+                .cloned()
+                .unwrap_or_default()
+                .get("url")
+                .cloned()
+                .unwrap_or_default()
+        )
+        .map_err(|_| "Failed to parse response body".to_string())?;
+
+    Ok(signed_url)
+}

package/rust/installer/bank.rs

@@ -1,33 +1,39 @@
 use std::path::{ Path, PathBuf };
 use crate::{
-    common::cdn::get_cdn_url,
     config::loader::{ add_bank_to_config, load_config },
-    installer::utils::{ download_file, extract_archive },
+    installer::{
+        addon::{ ask_api_for_signed_url, AddonType },
+        utils::{ download_file, extract_archive },
+    },
+    utils::logger::{ LogLevel, Logger },
 };
 
 pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/{}", cdn_url, name);
+    let logger = Logger::new();
+
+    let signed_url = ask_api_for_signed_url(AddonType::Bank, name).await?;
 
     let bank_dir = target_dir.join("bank");
     let archive_path = PathBuf::from(format!("./.deva/tmp/{}.devabank", name));
     let extract_path = bank_dir.join(name);
 
+    download_file(&signed_url, &archive_path).await.map_err(|e|
+        format!("Failed to download: {}", e)
+    )?;
+
     if extract_path.exists() {
-        println!(
-            "Bank '{}' already exists at '{}'. Skipping install.",
-            name,
-            extract_path.display()
+        logger.log_message(
+            LogLevel::Warning,
+            &format!(
+                "Bank '{}' already exists at '{}'. Skipping install.",
+                name,
+                extract_path.display()
+            )
         );
+
         return Ok(());
     }
 
-    download_file(&url, &archive_path).await.map_err(|e| format!("Failed to download: {}", e))?;
-
-    extract_archive(&archive_path, &extract_path).await.map_err(|e|
-        format!("Failed to extract: {}", e)
-    )?;
-
     // Add the bank to the config
     let root_dir = target_dir
         .parent()
@@ -49,6 +55,10 @@ pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {
 
     let dependency_path = &format!("devalang://bank/{}", name);
 
+    extract_archive(&archive_path, &extract_path).await.map_err(|e|
+        format!("Failed to extract: {}", e)
+    )?;
+
     add_bank_to_config(&mut config, &extract_path, &dependency_path);
 
     Ok(())

package/rust/installer/mod.rs

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

package/rust/installer/plugin.rs

@@ -0,0 +1,55 @@
+use std::path::{ Path, PathBuf };
+use crate::{
+    common::cdn::get_cdn_url,
+    config::loader::{ add_plugin_to_config, load_config },
+    installer::utils::{ download_file, extract_archive },
+};
+
+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("plugin");
+    let archive_path = PathBuf::from(format!("./.deva/tmp/{}.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_file(&url, &archive_path).await.map_err(|e| format!("Failed to download: {}", e))?;
+
+    extract_archive(&archive_path, &extract_path).await.map_err(|e|
+        format!("Failed to extract: {}", e)
+    )?;
+
+    // Add the plugin to the config
+    let root_dir = target_dir
+        .parent()
+        .ok_or_else(|| "Failed to determine root directory".to_string())?;
+
+    let config_path = root_dir.join(".devalang");
+    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);
+
+    add_plugin_to_config(&mut config, &extract_path, &dependency_path);
+
+    Ok(())
+}

package/rust/lib.rs

@@ -7,11 +7,11 @@ use wasm_bindgen::prelude::*;
 use serde_wasm_bindgen::to_value;
 
 use crate::core::{
-    audio::{ engine::AudioEngine, interpreter::driver::{ run_audio_program } },
+    audio::{ engine::AudioEngine, interpreter::driver::run_audio_program },
     parser::statement::{ Statement, StatementKind },
     preprocessor::loader::ModuleLoader,
     shared::value::Value,
-    store::global::GlobalStore,
+    store::{ function::FunctionTable, global::GlobalStore, variable::VariableTable },
     utils::path::normalize_path,
 };
 
@@ -69,16 +69,19 @@ pub fn render_audio(user_code: &str) -> Result<js_sys::Float32Array, JsValue> {
         .ok_or(JsValue::from_str("❌ No statements found for entry module"))?
         .clone();
 
-    let audio_engine = AudioEngine::new("wasm_output".to_string());
+    let mut audio_engine = AudioEngine::new("wasm_output".to_string());
 
-    let (final_engine, _, _) = run_audio_program(
+    let _ = run_audio_program(
         &main_statements,
-        audio_engine,
+        &mut audio_engine,
         "playground".to_string(),
-        "wasm_output".to_string()
+        "wasm_output".to_string(),
+        VariableTable::new(),
+        FunctionTable::new(),
+        &mut global_store
     );
 
-    let samples = final_engine.get_normalized_buffer();
+    let samples = audio_engine.get_normalized_buffer();
 
     if samples.is_empty() {
         return Err(JsValue::from_str("❌ Audio buffer is empty"));

package/rust/main.rs

@@ -15,18 +15,21 @@ use crate::{
             handle_bank_available_command,
             handle_bank_info_command,
             handle_bank_list_command,
-            handle_remove_bank_command, handle_update_bank_command,
+            handle_remove_bank_command,
+            handle_update_bank_command,
         },
         build::handle_build_command,
         check::handle_check_command,
         driver::{ BankCommand, Cli, Commands, InstallCommand, TemplateCommand },
         init::handle_init_command,
-        install::handle_install_bank_command,
+        install::handle_install_command,
+        login::handle_login_command,
         play::handle_play_command,
         template::{ handle_template_info_command, handle_template_list_command },
         update::handle_update_command,
     },
     config::{ driver::Config, loader::load_config },
+    installer::addon::AddonType,
 };
 
 #[tokio::main]
@@ -55,25 +58,35 @@ async fn main() -> io::Result<()> {
                 }
             }
 
-        Commands::Check { entry, output, watch, compilation_mode, debug } => {
-            handle_check_command(config, entry, output, watch);
+        Commands::Check { entry, output, watch, debug } => {
+            handle_check_command(config, entry, output, watch, debug);
         }
 
-        Commands::Build { entry, output, watch, compilation_mode, debug, compress } => {
-            handle_build_command(config, entry, output, watch);
+        Commands::Build { entry, output, watch, debug, compress } => {
+            handle_build_command(config, entry, output, watch, debug, compress);
         }
 
-        Commands::Play { entry, output, watch, repeat } => {
-            handle_play_command(config, entry, output, watch, repeat);
+        Commands::Play { entry, output, watch, repeat, debug } => {
+            handle_play_command(config, entry, output, watch, repeat, debug);
         }
 
         Commands::Install { command } =>
             match command {
                 InstallCommand::Bank { name } => {
-                    if let Err(err) = handle_install_bank_command(name).await {
+                    if let Err(err) = handle_install_command(name, AddonType::Bank).await {
                         eprintln!("❌ Failed to install bank: {}", err);
                     }
                 }
+                InstallCommand::Plugin { name } => {
+                    if let Err(err) = handle_install_command(name, AddonType::Plugin).await {
+                        eprintln!("❌ Failed to install plugin: {}", err);
+                    }
+                }
+                InstallCommand::Preset { name } => {
+                    if let Err(err) = handle_install_command(name, AddonType::Preset).await {
+                        eprintln!("❌ Failed to install preset: {}", err);
+                    }
+                }
             }
 
         Commands::Bank { command } =>
@@ -115,6 +128,16 @@ async fn main() -> io::Result<()> {
             }
         }
 
+        Commands::Login { .. } => {
+            if let Err(err) = handle_login_command().await {
+                eprintln!("❌ Login failed: {}", err);
+            }
+        }
+
+        Commands::Logout { .. } => {
+            eprintln!("❌ Logout command is not implemented yet.");
+        }
+
         _ => {}
     }
 

package/rust/utils/logger.rs

@@ -33,6 +33,22 @@ impl Logger {
         // no-op for WASM
     }
 
+    // --- log_message_with_trace ---
+
+    #[cfg(feature = "cli")]
+    pub fn log_message_with_trace(&self, level: LogLevel, message: &str, trace: Vec<&str>) {
+        let formatted_status = self.format_status(level);
+        println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
+        for t in trace {
+            println!("     ↳ {}", t);
+        }
+    }
+
+    #[cfg(not(feature = "cli"))]
+    pub fn log_message_with_trace(&self, _level: LogLevel, _message: &str, _trace: Vec<&str>) {
+        // no-op for WASM
+    }
+
     // --- log_error_with_stacktrace ---
 
     #[cfg(feature = "cli")]

package/rust/utils/mod.rs

@@ -3,4 +3,48 @@ pub mod signature;
 pub mod spinner;
 pub mod watcher;
 pub mod file;
-pub mod logger;
+pub mod logger;
+
+use crate::core::parser::statement::{Statement, StatementKind};
+use crate::core::error::ErrorResult;
+use crate::core::shared::value::Value;
+
+pub fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
+    let mut errors: Vec<ErrorResult> = Vec::new();
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Unknown => {
+                errors.push(ErrorResult {
+                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    errors.extend(collect_errors_recursively(body_statements));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    errors
+}
+
+pub fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
+    if let Value::Map(map) = value {
+        if let Some(Value::Block(statements)) = map.get("body") {
+            return Some(statements);
+        }
+    }
+    None
+}

package/rust/utils/spinner.rs

@@ -3,7 +3,7 @@ use indicatif::{ ProgressBar, ProgressStyle };
 use std::{ time::Duration };
 
 #[cfg(feature = "cli")]
-pub fn with_spinner<T, F>(start_msg: &str, f: F) -> T where F: FnOnce() -> T {
+pub fn with_spinner<T, F>(start_msg: &str, f: F) -> ProgressBar where F: FnOnce() -> T {
     let spinner = ProgressBar::new_spinner();
     spinner.set_style(
         ProgressStyle::with_template("{spinner:.green} {msg}")
@@ -15,7 +15,5 @@ pub fn with_spinner<T, F>(start_msg: &str, f: F) -> T where F: FnOnce() -> T {
 
     let result = f();
 
-    spinner.finish_and_clear();
-
-    result
+    spinner
 }