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

package/rust/macros/src/lib.rs

@@ -0,0 +1,52 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{ parse_macro_input, ItemFn, LitStr };
+
+#[proc_macro_attribute]
+pub fn export_plugin(args: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as ItemFn);
+
+    // default export name = function name
+    let export_name = if args.is_empty() {
+        input.sig.ident.to_string()
+    } else {
+        // accept single string literal: #[export_plugin("synth")]
+        let s = parse_macro_input!(args as LitStr);
+        s.value()
+    };
+
+    let fn_ident = &input.sig.ident;
+    let vis = &input.vis;
+    let sig = &input.sig;
+    let block = &input.block;
+
+    let wrapper_ident = syn::Ident::new(&export_name, fn_ident.span());
+
+    let expanded =
+        quote! {
+        #vis #sig #block
+
+        #[no_mangle]
+        pub extern "C" fn #wrapper_ident(
+            out_ptr: *mut f32,
+            out_len: i32,
+            freq: f32,
+            amp: f32,
+            duration_ms: i32,
+            sample_rate: i32,
+            channels: i32,
+        ) {
+            if out_ptr.is_null() { return; }
+            let out_len_usz = out_len.max(0) as usize;
+            let ch = channels.max(1) as usize;
+            let frames = (out_len_usz / ch) as u32;
+            let params = devalang_bindings::BufferParams { sample_rate: sample_rate.max(1) as u32, channels: channels.max(1) as u32, frames };
+            unsafe {
+                let out = core::slice::from_raw_parts_mut(out_ptr, out_len_usz);
+                #fn_ident(out, params, devalang_bindings::Note::default(), freq, amp, duration_ms.max(1) as u32);
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}

package/rust/main.rs

@@ -5,38 +5,38 @@ pub mod config;
 pub mod core;
 pub mod web;
 pub use devalang_utils as utils;
-use devalang_utils::path::ensure_deva_dir;
 
+use crate::cli::addon::commands::handle_install_addon_command;
+use crate::cli::addon::commands::handle_list_addon_command;
+use crate::cli::addon::commands::handle_remove_addon_command;
+use crate::cli::addon::commands::handle_update_addon_command;
+use crate::cli::me::commands::handle_me_command;
+use crate::cli::parser::AddonCommand;
 use crate::cli::telemetry::send::send_telemetry_event;
 use crate::config::settings::ensure_user_config_file_exists;
 use crate::config::settings::write_user_config_file;
 use crate::{
     cli::{
-        bank::{
-            handle_bank_available_command, handle_bank_info_command, handle_bank_list_command,
-            handle_remove_bank_command, handle_update_bank_command,
-        },
         build::commands::handle_build_command,
         check::handle_check_command,
         discover::commands::handle_discover_command,
         init::commands::handle_init_command,
-        install::commands::handle_install_command,
         login::commands::handle_login_command,
-        parser::{BankCommand, Cli, Commands, InstallCommand, TelemetryCommand, TemplateCommand},
+        parser::{Cli, Commands, TelemetryCommand, TemplateCommand},
         play::commands::handle_play_command,
         telemetry::{
             commands::{handle_telemetry_disable_command, handle_telemetry_enable_command},
             event_creator::{TelemetryEventCreator, TelemetryEventExt},
         },
         template::commands::{handle_template_info_command, handle_template_list_command},
-        update::commands::handle_update_command,
     },
     config::driver::ProjectConfig,
     utils::first_usage::check_is_first_usage,
 };
 use clap::CommandFactory;
 use clap::FromArgMatches;
-use devalang_types::{AddonType, TelemetryErrorLevel};
+use devalang_types::TelemetryErrorLevel;
+use devalang_utils::path::ensure_deva_dir;
 use std::io;
 
 #[tokio::main]
@@ -51,7 +51,7 @@ async fn main() -> io::Result<()> {
     cmd = cmd.version(version_static).before_help(signature_static);
 
     let raw_args: Vec<String> = std::env::args().collect();
-    if raw_args.iter().any(|a| (a == "--version" || a == "-V")) {
+    if raw_args.iter().any(|a| a == "--version" || a == "-V") {
         println!("{}", signature_static);
         return Ok(());
     }
@@ -107,7 +107,7 @@ async fn main() -> io::Result<()> {
                 let logger = devalang_utils::logger::Logger::new();
                 logger.log_message(
                     devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Check failed: {}", err),
+                    &format!("[error] Check failed: {}", err),
                 );
                 had_error = true;
                 last_error_message = Some(format!("check failed: {}", err));
@@ -139,7 +139,7 @@ async fn main() -> io::Result<()> {
                 let logger = devalang_utils::logger::Logger::new();
                 logger.log_message(
                     devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Build failed: {}", err),
+                    &format!("[error] Build failed: {}", err),
                 );
                 had_error = true;
                 last_error_message = Some(format!("build failed: {}", err));
@@ -169,7 +169,7 @@ async fn main() -> io::Result<()> {
                 let logger = devalang_utils::logger::Logger::new();
                 logger.log_message(
                     devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Play failed: {}", err),
+                    &format!("[error] Play failed: {}", err),
                 );
                 had_error = true;
                 last_error_message = Some(format!("play failed: {}", err));
@@ -177,144 +177,300 @@ async fn main() -> io::Result<()> {
             }
         }
 
-        Commands::Install { command } => match command {
-            InstallCommand::Template { name } => {
-                if let Err(err) = handle_install_command(name, AddonType::Template).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to install template: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("install template failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
-            InstallCommand::Bank { name } => {
-                if let Err(err) = handle_install_command(name, AddonType::Bank).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to install bank: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("install bank failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
-            InstallCommand::Plugin { name } => {
-                if let Err(err) = handle_install_command(name, AddonType::Plugin).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to install plugin: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("install plugin failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
-            InstallCommand::Preset { name } => {
-                if let Err(err) = handle_install_command(name, AddonType::Preset).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to install preset: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("install preset failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
-        },
-
-        Commands::Bank { command } => match command {
-            BankCommand::List => {
-                if let Err(err) = handle_bank_list_command().await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to list local banks: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("bank list failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
-
-            BankCommand::Available => {
-                if let Err(err) = handle_bank_available_command().await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to list available banks: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("bank available failed: {}", err));
-                    exit_code = Some(1);
+        Commands::Addon { command } => {
+            match command {
+                AddonCommand::Install { name, no_clear_tmp } => {
+                    if let Err(err) = handle_install_addon_command(name, no_clear_tmp).await {
+                        let logger = devalang_utils::logger::Logger::new();
+                        logger.log_message(
+                            devalang_utils::logger::LogLevel::Error,
+                            &format!("[error] Failed to install addon: {}", err),
+                        );
+                        had_error = true;
+                        last_error_message = Some(format!("install addon failed: {}", err));
+                        exit_code = Some(1);
+                    }
                 }
-            }
 
-            BankCommand::Info { name } => {
-                if let Err(err) = handle_bank_info_command(name).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to get bank info: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("bank info failed: {}", err));
-                    exit_code = Some(1);
+                AddonCommand::Update { name } => {
+                    if let Err(err) = handle_update_addon_command(name).await {
+                        let logger = devalang_utils::logger::Logger::new();
+                        logger.log_message(
+                            devalang_utils::logger::LogLevel::Error,
+                            &format!("[error] Failed to update addon: {}", err),
+                        );
+                        had_error = true;
+                        last_error_message = Some(format!("update addon failed: {}", err));
+                        exit_code = Some(1);
+                    }
                 }
-            }
-
-            BankCommand::Remove { name } => {
-                if let Err(err) = handle_remove_bank_command(name).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to remove bank: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("bank remove failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
 
-            BankCommand::Update { name } => {
-                if let Err(err) = handle_update_bank_command(name).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to update bank: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("bank update failed: {}", err));
-                    exit_code = Some(1);
+                AddonCommand::List {} => {
+                    if let Err(err) = handle_list_addon_command().await {
+                        let logger = devalang_utils::logger::Logger::new();
+                        logger.log_message(
+                            devalang_utils::logger::LogLevel::Error,
+                            &format!("[error] Failed to list local addons: {}", err),
+                        );
+                        had_error = true;
+                        last_error_message = Some(format!("addon list failed: {}", err));
+                        exit_code = Some(1);
+                    }
                 }
-            }
-        },
 
-        Commands::Update { only } => {
-            if let Err(err) = handle_update_command(only).await {
-                let logger = devalang_utils::logger::Logger::new();
-                logger.log_message(
-                    devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Update failed: {}", err),
-                );
-                had_error = true;
-                last_error_message = Some(format!("update failed: {}", err));
-                exit_code = Some(1);
+                AddonCommand::Remove { name } => {
+                    if let Err(err) = handle_remove_addon_command(name).await {
+                        let logger = devalang_utils::logger::Logger::new();
+                        logger.log_message(
+                            devalang_utils::logger::LogLevel::Error,
+                            &format!("[error] Failed to remove addon: {}", err),
+                        );
+                        had_error = true;
+                        last_error_message = Some(format!("remove addon failed: {}", err));
+                        exit_code = Some(1);
+                    }
+                } // AddonCommand::Bank { command } => {
+                  //     match command {
+                  //         BankCommand::List => {
+                  //             if let Err(err) = handle_bank_list_command().await {
+                  //                 let logger = devalang_utils::logger::Logger::new();
+                  //                 logger.log_message(
+                  //                     devalang_utils::logger::LogLevel::Error,
+                  //                     &format!("[error] Failed to list local banks: {}", err)
+                  //                 );
+                  //                 had_error = true;
+                  //                 last_error_message = Some(format!("bank list failed: {}", err));
+                  //                 exit_code = Some(1);
+                  //             }
+                  //         }
+
+                  //         BankCommand::Available => {
+                  //             if let Err(err) = handle_bank_available_command().await {
+                  //                 let logger = devalang_utils::logger::Logger::new();
+                  //                 logger.log_message(
+                  //                     devalang_utils::logger::LogLevel::Error,
+                  //                     &format!("[error] Failed to list available banks: {}", err)
+                  //                 );
+                  //                 had_error = true;
+                  //                 last_error_message = Some(
+                  //                     format!("bank available failed: {}", err)
+                  //                 );
+                  //                 exit_code = Some(1);
+                  //             }
+                  //         }
+
+                  //         // BankCommand::Info { name } => {
+                  //         //     if let Err(err) = handle_bank_info_command(name).await {
+                  //         //         let logger = devalang_utils::logger::Logger::new();
+                  //         //         logger.log_message(
+                  //         //             devalang_utils::logger::LogLevel::Error,
+                  //         //             &format!("[error] Failed to get bank info: {}", err)
+                  //         //         );
+                  //         //         had_error = true;
+                  //         //         last_error_message = Some(format!("bank info failed: {}", err));
+                  //         //         exit_code = Some(1);
+                  //         //     }
+                  //         // }
+
+                  //         // BankCommand::Remove { name } => {
+                  //         //     if let Err(err) = handle_remove_bank_command(name).await {
+                  //         //         let logger = devalang_utils::logger::Logger::new();
+                  //         //         logger.log_message(
+                  //         //             devalang_utils::logger::LogLevel::Error,
+                  //         //             &format!("[error] Failed to remove bank: {}", err)
+                  //         //         );
+                  //         //         had_error = true;
+                  //         //         last_error_message = Some(format!("bank remove failed: {}", err));
+                  //         //         exit_code = Some(1);
+                  //         //     }
+                  //         // }
+
+                  //         // BankCommand::Update { name } => {
+                  //         //     if let Err(err) = handle_update_bank_command(name).await {
+                  //         //         let logger = devalang_utils::logger::Logger::new();
+                  //         //         logger.log_message(
+                  //         //             devalang_utils::logger::LogLevel::Error,
+                  //         //             &format!("[error] Failed to update bank: {}", err)
+                  //         //         );
+                  //         //         had_error = true;
+                  //         //         last_error_message = Some(format!("bank update failed: {}", err));
+                  //         //         exit_code = Some(1);
+                  //         //     }
+                  //         // }
+                  //     }
+                  // }
+
+                  // AddonCommand::Plugin { command} => {
+                  //     match command {
+                  //         PluginCommand::List => {
+                  //             if let Err(err) = handle_plugin_list_command().await {
+                  //                 let logger = devalang_utils::logger::Logger::new();
+                  //                 logger.log_message(
+                  //                     devalang_utils::logger::LogLevel::Error,
+                  //                     &format!("[error] Failed to list local plugins: {}", err)
+                  //                 );
+                  //                 had_error = true;
+                  //                 last_error_message = Some(format!("plugin list failed: {}", err));
+                  //                 exit_code = Some(1);
+                  //             }
+                  //         }
+
+                  //         PluginCommand::Available => {
+                  //             if let Err(err) = handle_plugin_available_command().await {
+                  //                 let logger = devalang_utils::logger::Logger::new();
+                  //                 logger.log_message(
+                  //                     devalang_utils::logger::LogLevel::Error,
+                  //                     &format!("[error] Failed to list available plugins: {}", err)
+                  //                 );
+                  //                 had_error = true;
+                  //                 last_error_message = Some(
+                  //                     format!("plugin available failed: {}", err)
+                  //                 );
+                  //                 exit_code = Some(1);
+                  //             }
+                  //         }
+                  //     }
+                  // }
             }
         }
 
+        // Commands::Install { command } => match command {
+        //     InstallCommand::Template { name } => {
+        //         if let Err(err) = handle_install_command(name, AddonType::Template).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to install template: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("install template failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+        //     InstallCommand::Bank { name } => {
+        //         if let Err(err) = handle_install_command(name, AddonType::Bank).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to install bank: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("install bank failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+        //     InstallCommand::Plugin { name } => {
+        //         if let Err(err) = handle_install_command(name, AddonType::Plugin).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to install plugin: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("install plugin failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+        //     InstallCommand::Preset { name } => {
+        //         if let Err(err) = handle_install_command(name, AddonType::Preset).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to install preset: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("install preset failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+        // },
+
+        // Commands::Bank { command } => match command {
+        //     BankCommand::List => {
+        //         if let Err(err) = handle_bank_list_command().await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to list local banks: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("bank list failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+
+        //     BankCommand::Available => {
+        //         if let Err(err) = handle_bank_available_command().await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to list available banks: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("bank available failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+
+        //     BankCommand::Info { name } => {
+        //         if let Err(err) = handle_bank_info_command(name).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to get bank info: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("bank info failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+
+        //     BankCommand::Remove { name } => {
+        //         if let Err(err) = handle_remove_bank_command(name).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to remove bank: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("bank remove failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+
+        //     BankCommand::Update { name } => {
+        //         if let Err(err) = handle_update_bank_command(name).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to update bank: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("bank update failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+        // },
+
+        // Commands::Update { only } => {
+        //     if let Err(err) = handle_update_command(only).await {
+        //         let logger = devalang_utils::logger::Logger::new();
+        //         logger.log_message(
+        //             devalang_utils::logger::LogLevel::Error,
+        //             &format!("[error] Update failed: {}", err)
+        //         );
+        //         had_error = true;
+        //         last_error_message = Some(format!("update failed: {}", err));
+        //         exit_code = Some(1);
+        //     }
+        // }
         Commands::Telemetry { command } => match command {
             TelemetryCommand::Enable { .. } => {
                 if let Err(err) = handle_telemetry_enable_command().await {
                     let logger = devalang_utils::logger::Logger::new();
                     logger.log_message(
                         devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to enable telemetry: {}", err),
+                        &format!("[error] Failed to enable telemetry: {}", err),
                     );
                     had_error = true;
                     last_error_message = Some(format!("telemetry enable failed: {}", err));
@@ -326,7 +482,7 @@ async fn main() -> io::Result<()> {
                     let logger = devalang_utils::logger::Logger::new();
                     logger.log_message(
                         devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to disable telemetry: {}", err),
+                        &format!("[error] Failed to disable telemetry: {}", err),
                     );
                     had_error = true;
                     last_error_message = Some(format!("telemetry disable failed: {}", err));
@@ -335,12 +491,12 @@ async fn main() -> io::Result<()> {
             }
         },
 
-        Commands::Discover {} => {
-            if let Err(err) = handle_discover_command().await {
+        Commands::Discover { no_clear_tmp } => {
+            if let Err(err) = handle_discover_command(no_clear_tmp).await {
                 let logger = devalang_utils::logger::Logger::new();
                 logger.log_message(
                     devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Failed to discover: {}", err),
+                    &format!("[error] Failed to discover: {}", err),
                 );
                 had_error = true;
                 last_error_message = Some(format!("discover failed: {}", err));
@@ -353,7 +509,7 @@ async fn main() -> io::Result<()> {
                 let logger = devalang_utils::logger::Logger::new();
                 logger.log_message(
                     devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Login failed: {}", err),
+                    &format!("[error] Login failed: {}", err),
                 );
                 had_error = true;
                 last_error_message = Some(format!("login failed: {}", err));
@@ -361,11 +517,24 @@ async fn main() -> io::Result<()> {
             }
         }
 
+        Commands::Me {} => {
+            if let Err(err) = handle_me_command().await {
+                let logger = devalang_utils::logger::Logger::new();
+                logger.log_message(
+                    devalang_utils::logger::LogLevel::Error,
+                    &format!("[error] Me command failed: {}", err),
+                );
+                had_error = true;
+                last_error_message = Some(format!("me command failed: {}", err));
+                exit_code = Some(1);
+            }
+        }
+
         Commands::Logout { .. } => {
             let logger = devalang_utils::logger::Logger::new();
             logger.log_message(
                 devalang_utils::logger::LogLevel::Error,
-                "❌ Logout command is not implemented yet.",
+                "[error] Logout command is not implemented yet.",
             );
             had_error = true;
             last_error_message = Some("logout not implemented".to_string());

package/rust/types/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "devalang_types"
-version = "0.0.3"
+version = "0.0.4"
 description = "Types and traits for Devalang"
 license = "MIT"
 authors = ["Devaloop <contact@devaloop.com>"]

package/rust/types/src/addons.rs

@@ -4,6 +4,7 @@ use serde::Deserialize;
 pub struct DiscoveredAddon {
     pub path: std::path::PathBuf,
     pub name: String,
+    pub publisher: String,
     pub extension: String,
     pub addon_type: String,
 }
@@ -12,6 +13,7 @@ pub struct DiscoveredAddon {
 pub struct AddonWithMetadata {
     pub name: String,
     pub path: String,
+    pub publisher: String,
     pub addon_type: String,
     pub metadata: AddonMetadata,
 }
@@ -19,7 +21,7 @@ pub struct AddonWithMetadata {
 #[derive(Debug, Clone)]
 pub struct AddonMetadata {
     pub name: String,
-    pub author: String,
+    pub publisher: String,
     pub version: String,
     pub description: String,
     pub access: String,