@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/cli/discover/metadata.rs

@@ -1,48 +0,0 @@
-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

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

package/rust/cli/init/commands.rs

@@ -1,88 +0,0 @@
-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

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

package/rust/cli/install/addon.rs

@@ -1,118 +0,0 @@
-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

@@ -1,72 +0,0 @@
-use crate::{
-    cli::install::addon::ask_api_for_signed_url, config::ops::load_config,
-    web::cdn::download_from_cdn,
-};
-use devalang_core::config::driver::ProjectConfigExt;
-use devalang_types::AddonType;
-use devalang_types::ProjectConfigBankEntry;
-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 mut 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))?;
-
-    // Add the bank to the config if not already present
-    if config.banks.is_none() {
-        config.banks = Some(Vec::new());
-    }
-
-    if let Some(banks) = config.banks.as_mut() {
-        let exists = banks.iter().any(|b| b.path == dependency_path);
-        if !exists {
-            banks.push(ProjectConfigBankEntry {
-                path: dependency_path.clone(),
-                version: None,
-            });
-
-            if let Err(e) = config.write_config(&config) {
-                eprintln!("Warning: failed to write config: {}", e);
-            }
-        }
-    }
-
-    Ok(())
-}

package/rust/cli/install/commands.rs

@@ -1,35 +0,0 @@
-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

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

package/rust/cli/install/plugin.rs

@@ -1,80 +0,0 @@
-use crate::{
-    config::ops::load_config,
-    web::cdn::{download_from_cdn, get_cdn_url},
-};
-use devalang_core::config::driver::ProjectConfigExt;
-use devalang_types::ProjectConfigPluginEntry;
-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 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);
-
-    devalang_utils::file::extract_zip_safely(&archive_path, &extract_path)
-        .map_err(|e| format!("Failed to extract: {}", e))?;
-
-    // Add the plugin to the config if not already present
-    if config.plugins.is_none() {
-        config.plugins = Some(Vec::new());
-    }
-
-    if let Some(plugins) = config.plugins.as_mut() {
-        let exists = plugins.iter().any(|p| p.path == dependency_path);
-        if !exists {
-            plugins.push(ProjectConfigPluginEntry {
-                path: dependency_path.clone(),
-                version: None,
-            });
-
-            if let Err(e) = config.write_config(&config) {
-                eprintln!("Warning: failed to write config: {}", e);
-            }
-        }
-    }
-
-    Ok(())
-}

package/rust/cli/login/commands.rs

@@ -1,124 +0,0 @@
-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

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

package/rust/cli/mod.rs

@@ -1,12 +0,0 @@
-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;
-pub mod update;