@devaloop/devalang 0.0.1-alpha.8 → 0.0.1-beta.1

package/rust/cli/discover/metadata.rs

@@ -0,0 +1,48 @@
+use devalang_types::AddonMetadata;
+use toml::Value;
+
+pub fn parse_metadata_file(addon_type: &str, metadata_content: &str) -> Option<AddonMetadata> {
+    let parsed = metadata_content.parse::<Value>().ok()?;
+
+    let table = (match addon_type {
+        "bank" => parsed.get("bank"),
+        "plugin" => parsed.get("plugin"),
+        "preset" => parsed.get("preset"),
+        "template" => parsed.get("template"),
+        _ => None,
+    })?;
+
+    let name = table
+        .get("name")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let version = table
+        .get("version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let description = table
+        .get("description")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let author = table
+        .get("author")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown")
+        .to_string();
+    let access = table
+        .get("access")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+
+    Some(AddonMetadata {
+        name,
+        author,
+        version,
+        description,
+        access,
+    })
+}

package/rust/cli/discover/mod.rs

@@ -0,0 +1,5 @@
+pub mod commands;
+pub mod config;
+pub mod fs;
+pub mod install;
+pub mod metadata;

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

@@ -1,29 +1,35 @@
-use std::{ fs, path::Path };
-use include_dir::{ include_dir, Dir };
-use crate::{ cli::template::get_available_templates, utils::file::copy_dir_recursive };
+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::{ Select, Confirm };
+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()
-        });
+    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);
-            })
+        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() {
@@ -34,12 +40,11 @@ pub fn handle_init_command(name: Option<String>, template: Option<String>) {
     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);
+            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.");
@@ -65,7 +70,11 @@ pub fn handle_init_command(name: Option<String>, template: Option<String>) {
         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());
+        println!(
+            "✅ Initialized '{}' project in: {}",
+            project_name,
+            target_path.display()
+        );
     }
 }
 
@@ -75,5 +84,5 @@ fn scaffold_project_current_dir(path: &Path, template: String) {
         std::process::exit(1);
     });
 
-    copy_dir_recursive(template_dir, path, &template_dir.path());
+    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,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)
+    }
+}

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/commands.rs

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

package/rust/cli/install/mod.rs

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

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/commands.rs

@@ -0,0 +1,124 @@
+use crate::config::settings::set_user_config_value;
+use crate::web::sso::get_sso_url;
+use std::str::FromStr;
+use tiny_http::Header;
+use tiny_http::{Response, Server};
+use webbrowser;
+
+/// Handle the login command
+/// 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 devalang_utils::logger::LogLevel;
+    use devalang_utils::logger::Logger;
+    use devalang_utils::spinner::start_spinner;
+
+    let logger = Logger::new();
+
+    let mut listener_port = 7878;
+
+    let test_port_already_in_use = format!("127.0.0.1:{}", listener_port);
+    while std::net::TcpListener::bind(&test_port_already_in_use).is_err() {
+        listener_port += 1;
+    }
+
+    let redirect_uri = format!("http://127.0.0.1:{}/callback", listener_port);
+    let login_url = format!(
+        "{}/?response_type=code&referer=cli&redirect_uri={}",
+        get_sso_url(),
+        redirect_uri
+    );
+
+    if webbrowser::open(&login_url).is_ok() {
+        logger.log_message(LogLevel::Info, "Opening browser for login...");
+        logger.log_message(
+            LogLevel::Info,
+            &format!(
+                "If the browser does not open, please visit the following URL: {}",
+                login_url
+            ),
+        );
+    } else {
+        logger.log_message(
+            LogLevel::Info,
+            "Please open the following URL in your browser to login:",
+        );
+        logger.log_message(LogLevel::Info, &login_url);
+    }
+
+    let server = Server::http(format!("127.0.0.1:{}", listener_port)).unwrap();
+
+    let spinner = start_spinner("Waiting for authentication...");
+
+    for request in server.incoming_requests() {
+        let query = request.url().to_string();
+        if request.url().starts_with("/callback") {
+            if query.contains("session=") || query.contains("error=") {
+                let token = query.split("session=").nth(1).unwrap_or("").to_string();
+
+                if !token.is_empty() {
+                    let response_html = r#"
+                        <html>
+                            <body>
+                                <h1>Authentication Successful</h1>
+                                <h2>You can now close this window.</h2>
+                            </body>
+                        </html>
+                    "#;
+
+                    let response = Response::from_string(response_html)
+                        .with_status_code(200)
+                        .with_header(Header::from_str("Content-Type: text/html").unwrap());
+
+                    request.respond(response).unwrap();
+
+                    save_token(&token);
+
+                    spinner.finish_and_clear();
+
+                    logger.log_message(
+                        LogLevel::Success,
+                        "Authentication successful. Token saved to ~/.devalang/config.json",
+                    );
+
+                    break;
+                } else {
+                    spinner.finish_and_clear();
+                    logger.log_message(LogLevel::Error, "Invalid session token.");
+                    request
+                        .respond(Response::from_string("Invalid session token."))
+                        .unwrap();
+
+                    break;
+                }
+            } else {
+                println!("Invalid callback: {}", request.url());
+
+                spinner.finish_and_clear();
+                logger.log_message(LogLevel::Error, "Invalid callback.");
+                request
+                    .respond(Response::from_string("Invalid callback."))
+                    .unwrap();
+
+                break;
+            }
+        } else if request.url().starts_with("/favicon.ico") {
+            // Ignore favicon requests
+        } else {
+            spinner.finish_and_clear();
+            logger.log_message(LogLevel::Error, "Invalid request.");
+            request
+                .respond(Response::from_string("Invalid request."))
+                .unwrap();
+
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+/// Save the session token to a file in the user's home directory
+fn save_token(token: &str) {
+    set_user_config_value("session", serde_json::Value::String(token.to_string()));
+}

package/rust/cli/login/mod.rs

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