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

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/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/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
 }