@devaloop/devalang 0.0.1-beta.3 → 0.1.1

package/rust/cli/addon/remove.rs

@@ -1,271 +0,0 @@
-use crate::config::ops::load_config;
-use devalang_core::config::driver::ProjectConfigExt;
-use devalang_utils::path as path_utils;
-use std::fs;
-
-pub async fn remove_addon(name: String) -> Result<(), String> {
-    let deva_dir = path_utils::ensure_deva_dir()?;
-
-    // Helper to extract publisher from a slug like 'publisher.name'
-    let extract_publisher = |s: &str| s.splitn(2, '.').next().unwrap_or("").to_string();
-
-    // Try to find in config first (banks/plugins)
-    if let Ok(config_path) = path_utils::get_devalang_config_path() {
-        if let Some(mut config) = load_config(Some(&config_path)) {
-            // BANKS
-            if let Some(banks) = config.banks.as_mut() {
-                if let Some(pos) = banks.iter().position(|b| {
-                    let slug = b.path.strip_prefix("devalang://bank/").unwrap_or(&b.path);
-                    // accept exact slug, exact path, or match by local name suffix (publisher/name or publisher.name)
-                    slug == name
-                        || b.path == name
-                        || slug.ends_with(&format!("/{}", name))
-                        || slug.ends_with(&format!(".{}", name))
-                }) {
-                    let entry = banks.remove(pos);
-                    let slug = entry
-                        .path
-                        .strip_prefix("devalang://bank/")
-                        .unwrap_or(&entry.path)
-                        .to_string();
-
-                    // parse publisher/name from slug (support 'publisher/name' or 'publisher.name')
-                    let (publisher, local_name) = if slug.contains('/') {
-                        let mut it = slug.splitn(2, '/');
-                        (
-                            it.next().unwrap().to_string(),
-                            it.next().unwrap().to_string(),
-                        )
-                    } else if slug.contains('.') {
-                        let mut it = slug.splitn(2, '.');
-                        (
-                            it.next().unwrap().to_string(),
-                            it.next().unwrap().to_string(),
-                        )
-                    } else {
-                        return Err(format!("Cannot parse bank slug '{}'", slug));
-                    };
-
-                    let local_path = deva_dir.join("banks").join(&publisher).join(&local_name);
-
-                    if !local_path.exists() {
-                        return Err(format!(
-                            "Local files for bank '{}' not found at '{}', aborting",
-                            slug,
-                            local_path.display()
-                        ));
-                    }
-
-                    fs::remove_dir_all(&local_path)
-                        .map_err(|e| format!("Failed to remove addon files: {}", e))?;
-
-                    if let Err(e) = config.write_config(&config) {
-                        eprintln!("Warning: failed to write updated config: {}", e);
-                    }
-
-                    println!("✅ Bank '{}' removed (publisher '{}')", slug, publisher);
-                    return Ok(());
-                }
-            }
-
-            // PLUGINS
-            if let Some(plugins) = config.plugins.as_mut() {
-                if let Some(pos) = plugins.iter().position(|p| {
-                    let slug = p.path.strip_prefix("devalang://plugin/").unwrap_or(&p.path);
-                    // accept exact slug, exact path, or match by local name suffix
-                    slug == name
-                        || p.path == name
-                        || slug.ends_with(&format!("/{}", name))
-                        || slug.ends_with(&format!(".{}", name))
-                }) {
-                    let entry = plugins.remove(pos);
-                    let slug = entry
-                        .path
-                        .strip_prefix("devalang://plugin/")
-                        .unwrap_or(&entry.path)
-                        .to_string();
-
-                    // parse publisher/name from slug (support 'publisher/name' or 'publisher.name')
-                    let (publisher, local_name) = if slug.contains('/') {
-                        let mut it = slug.splitn(2, '/');
-                        (
-                            it.next().unwrap().to_string(),
-                            it.next().unwrap().to_string(),
-                        )
-                    } else if slug.contains('.') {
-                        let mut it = slug.splitn(2, '.');
-                        (
-                            it.next().unwrap().to_string(),
-                            it.next().unwrap().to_string(),
-                        )
-                    } else {
-                        return Err(format!("Cannot parse plugin slug '{}'", slug));
-                    };
-
-                    let local_path = deva_dir.join("plugins").join(&publisher).join(&local_name);
-
-                    if !local_path.exists() {
-                        return Err(format!(
-                            "Local files for plugin '{}' not found at '{}', aborting",
-                            slug,
-                            local_path.display()
-                        ));
-                    }
-
-                    fs::remove_dir_all(&local_path)
-                        .map_err(|e| format!("Failed to remove addon files: {}", e))?;
-
-                    if let Err(e) = config.write_config(&config) {
-                        eprintln!("Warning: failed to write updated config: {}", e);
-                    }
-
-                    println!("✅ Plugin '{}' removed (publisher '{}')", slug, publisher);
-                    return Ok(());
-                }
-            }
-        }
-    }
-
-    // Not found in config: search filesystem under .deva and infer type
-    let dirs = ["banks", "plugins", "presets", "templates"];
-    for &d in &dirs {
-        let folder = deva_dir.join(d);
-        if !folder.exists() {
-            continue;
-        }
-
-        // If name looks like a slug (contains '.' or '/'), parse publisher and name and try candidate paths
-        if name.contains('.') || name.contains('/') {
-            let (publisher, local_name) = if name.contains('/') {
-                let mut it = name.splitn(2, '/');
-                (
-                    it.next().unwrap().to_string(),
-                    it.next().unwrap().to_string(),
-                )
-            } else {
-                let mut it = name.splitn(2, '.');
-                (
-                    it.next().unwrap().to_string(),
-                    it.next().unwrap().to_string(),
-                )
-            };
-
-            let candidate1 = folder.join(&publisher).join(&local_name);
-            let candidate2 = folder.join(format!("{}.{}", publisher, local_name));
-            let candidate3 = folder.join(&name);
-
-            let candidate = if candidate1.exists() {
-                candidate1
-            } else if candidate2.exists() {
-                candidate2
-            } else {
-                candidate3
-            };
-
-            if candidate.exists() {
-                fs::remove_dir_all(&candidate)
-                    .map_err(|e| format!("Failed to remove addon files: {}", e))?;
-
-                // also attempt to remove from config if possible
-                if let Ok(config_path) = path_utils::get_devalang_config_path() {
-                    if let Some(mut config) = load_config(Some(&config_path)) {
-                        match d {
-                            "banks" => {
-                                if let Some(banks) = config.banks.as_mut() {
-                                    let pattern1 =
-                                        format!("devalang://bank/{}/{}", publisher, local_name);
-                                    let pattern2 =
-                                        format!("devalang://bank/{}.{}", publisher, local_name);
-                                    banks.retain(|b| {
-                                        b.path != pattern1
-                                            && b.path != pattern2
-                                            && !b.path.ends_with(&local_name)
-                                    });
-                                }
-                            }
-                            "plugins" => {
-                                if let Some(plugins) = config.plugins.as_mut() {
-                                    let pattern1 =
-                                        format!("devalang://plugin/{}/{}", publisher, local_name);
-                                    let pattern2 =
-                                        format!("devalang://plugin/{}.{}", publisher, local_name);
-                                    plugins.retain(|p| {
-                                        p.path != pattern1
-                                            && p.path != pattern2
-                                            && !p.path.ends_with(&local_name)
-                                    });
-                                }
-                            }
-                            _ => {}
-                        }
-
-                        if let Err(e) = config.write_config(&config) {
-                            eprintln!("Warning: failed to write updated config: {}", e);
-                        }
-                    }
-                }
-
-                println!(
-                    "✅ Addon '{}/{}' removed from .deva/{} (publisher '{}')",
-                    publisher, local_name, d, publisher
-                );
-                return Ok(());
-            }
-        }
-
-        // Otherwise, scan directory entries: match exact name or suffix '.name'
-        if let Ok(entries) = fs::read_dir(&folder) {
-            for entry in entries.flatten() {
-                if let Ok(file_type) = entry.file_type() {
-                    if !file_type.is_dir() {
-                        continue;
-                    }
-                }
-                let file_name = entry.file_name();
-                let file_name = file_name.to_string_lossy();
-                if file_name == name || file_name.ends_with(&format!(".{}", name)) {
-                    let slug = file_name.to_string();
-                    let publisher = extract_publisher(&slug);
-                    let path = entry.path();
-                    fs::remove_dir_all(&path)
-                        .map_err(|e| format!("Failed to remove addon files: {}", e))?;
-
-                    // try to remove from config when banks/plugins
-                    if let Ok(config_path) = path_utils::get_devalang_config_path() {
-                        if let Some(mut config) = load_config(Some(&config_path)) {
-                            match d {
-                                "banks" => {
-                                    if let Some(banks) = config.banks.as_mut() {
-                                        banks.retain(|b| {
-                                            b.path != format!("devalang://bank/{}", slug)
-                                        });
-                                    }
-                                }
-                                "plugins" => {
-                                    if let Some(plugins) = config.plugins.as_mut() {
-                                        plugins.retain(|p| {
-                                            p.path != format!("devalang://plugin/{}", slug)
-                                        });
-                                    }
-                                }
-                                _ => {}
-                            }
-
-                            if let Err(e) = config.write_config(&config) {
-                                eprintln!("Warning: failed to write updated config: {}", e);
-                            }
-                        }
-                    }
-
-                    println!(
-                        "✅ Addon '{}' removed from .deva/{} (publisher '{}')",
-                        slug, d, publisher
-                    );
-                    return Ok(());
-                }
-            }
-        }
-    }
-
-    Err(format!("Addon '{}' not found", name))
-}

package/rust/cli/addon/update.rs

@@ -1,305 +0,0 @@
-use crate::config::ops::load_config;
-use crate::{
-    cli::addon::{
-        download::download_addon,
-        metadata::{get_addon_from_api, get_addon_publisher_from_api},
-    },
-    web::cdn::get_cdn_url,
-};
-use devalang_core::config::driver::ProjectConfigExt;
-use devalang_types::AddonType;
-use devalang_utils::path as path_utils;
-use std::fs;
-use toml::Value as TomlValue;
-
-#[derive(serde::Deserialize)]
-pub struct AddonVersion {
-    pub version: String,
-}
-
-async fn fetch_latest_version(
-    addon_type: AddonType,
-    addon_name: String,
-) -> Result<AddonVersion, Box<dyn std::error::Error>> {
-    let cdn_url = get_cdn_url();
-
-    let addon_type = match addon_type {
-        AddonType::Bank => "bank",
-        AddonType::Plugin => "plugin",
-        AddonType::Preset => "preset",
-        AddonType::Template => "template",
-    };
-
-    let publisher_identifier = get_addon_publisher_from_api(&addon_name)
-        .await
-        .unwrap_or("unknown".to_string());
-
-    let url = format!(
-        "{}/{}/{}/{}/version",
-        cdn_url, addon_type, publisher_identifier, addon_name
-    );
-
-    let response = reqwest::get(url).await?;
-
-    if !response.status().is_success() {
-        return Err(format!("❌ Failed to fetch version: HTTP {}", response.status()).into());
-    }
-
-    let bytes = response.bytes().await?;
-
-    let version: AddonVersion = serde_json::from_slice(&bytes)?;
-
-    Ok(version)
-}
-
-pub async fn update_addon(slug: String) -> Result<(), String> {
-    let addon_metadata = get_addon_from_api(&slug).await?;
-    let deva_dir = path_utils::ensure_deva_dir()?;
-
-    // Represent the addon as "<publisher>.<addon>" for user-visible names
-    let publisher_and_name = format!("{}.{}", addon_metadata.publisher, addon_metadata.name);
-
-    match addon_metadata.addon_type {
-        devalang_types::AddonType::Bank => {
-            match fetch_latest_version(
-                addon_metadata.addon_type.clone(),
-                addon_metadata.name.clone(),
-            )
-            .await
-            {
-                Ok(latest) => {
-                    // Determine local version from bank.toml if available
-                    let local_bank_path = deva_dir
-                        .join("banks")
-                        .join(&addon_metadata.publisher)
-                        .join(&addon_metadata.name);
-                    let local_version = if local_bank_path.exists() {
-                        let bank_toml = local_bank_path.join("bank.toml");
-                        if bank_toml.exists() {
-                            if let Ok(content) = fs::read_to_string(&bank_toml) {
-                                if let Ok(parsed) =
-                                    toml::from_str::<devalang_types::BankFile>(&content)
-                                {
-                                    parsed.bank.version
-                                } else {
-                                    String::new()
-                                }
-                            } else {
-                                String::new()
-                            }
-                        } else {
-                            String::new()
-                        }
-                    } else {
-                        String::new()
-                    };
-
-                    if local_version != latest.version {
-                        println!(
-                            "Updating bank '{}' from '{}' to '{}'...",
-                            publisher_and_name, local_version, latest.version
-                        );
-
-                        // remove existing folder if present
-                        let bank_dir = deva_dir
-                            .join("banks")
-                            .join(&addon_metadata.publisher)
-                            .join(&addon_metadata.name);
-                        if bank_dir.exists() {
-                            fs::remove_dir_all(&bank_dir)
-                                .map_err(|e| format!("Failed to remove old bank files: {}", e))?;
-                        }
-
-                        // download new (use publisher.addon as the external identifier)
-                        download_addon(&publisher_and_name, &addon_metadata).await?;
-
-                        // update config version when present
-                        if let Ok(config_path) = path_utils::get_devalang_config_path() {
-                            if let Some(mut config) = load_config(Some(&config_path)) {
-                                if let Some(banks) = config.banks.as_mut() {
-                                    for bank in banks.iter_mut() {
-                                        let name_in_path = bank
-                                            .path
-                                            .strip_prefix("devalang://bank/")
-                                            .unwrap_or(&bank.path);
-                                    }
-
-                                    if let Err(e) = config.write_config(&config) {
-                                        eprintln!("Warning: failed to write updated config: {}", e);
-                                    }
-                                }
-                            }
-                        }
-
-                        println!(
-                            "✅ Bank '{}' updated to version '{}'",
-                            publisher_and_name, latest.version
-                        );
-                    } else {
-                        println!(
-                            "Bank '{}' is already up-to-date (version {})",
-                            publisher_and_name, latest.version
-                        );
-                    }
-                }
-                Err(e) => {
-                    return Err(format!(
-                        "Failed to fetch latest version for bank '{}': {}",
-                        publisher_and_name, e
-                    ));
-                }
-            }
-        }
-
-        devalang_types::AddonType::Plugin => {
-            // Try to fetch latest version via CDN API; if available compare, otherwise fallback to redownload
-            match fetch_latest_version(
-                addon_metadata.addon_type.clone(),
-                addon_metadata.name.clone(),
-            )
-            .await
-            {
-                Ok(latest) => {
-                    // Determine local plugin version by reading plugin.toml from preferred or fallback layout
-                    let preferred = deva_dir.join("plugins").join(format!(
-                        "{}/{}",
-                        addon_metadata.publisher, addon_metadata.name
-                    ));
-                    let fallback = deva_dir
-                        .join("plugins")
-                        .join(&addon_metadata.publisher)
-                        .join(&addon_metadata.name);
-
-                    let mut local_version = String::new();
-                    for candidate in [&preferred, &fallback] {
-                        let toml_path = candidate.join("plugin.toml");
-                        if toml_path.exists() {
-                            if let Ok(content) = fs::read_to_string(&toml_path) {
-                                if let Ok(value) = toml::from_str::<TomlValue>(&content) {
-                                    if let Some(v) = value
-                                        .get("plugin")
-                                        .and_then(|p| p.get("version"))
-                                        .and_then(|s| s.as_str())
-                                    {
-                                        local_version = v.to_string();
-                                    }
-                                }
-                            }
-                            break;
-                        }
-                    }
-
-                    if local_version != latest.version {
-                        println!(
-                            "Updating plugin '{}' from '{}' to '{}'...",
-                            publisher_and_name, local_version, latest.version
-                        );
-
-                        // remove any existing layout
-                        if preferred.exists() {
-                            fs::remove_dir_all(&preferred)
-                                .map_err(|e| format!("Failed to remove old plugin files: {}", e))?;
-                        }
-                        if fallback.exists() {
-                            fs::remove_dir_all(&fallback)
-                                .map_err(|e| format!("Failed to remove old plugin files: {}", e))?;
-                        }
-
-                        // download new
-                        download_addon(&publisher_and_name, &addon_metadata).await?;
-
-                        // update config version when present
-                        if let Ok(config_path) = path_utils::get_devalang_config_path() {
-                            if let Some(mut config) = load_config(Some(&config_path)) {
-                                if let Some(plugins) = config.plugins.as_mut() {
-                                    for p in plugins.iter_mut() {
-                                        let name_in_path = p
-                                            .path
-                                            .strip_prefix("devalang://plugin/")
-                                            .unwrap_or(&p.path);
-                                    }
-
-                                    if let Err(e) = config.write_config(&config) {
-                                        eprintln!("Warning: failed to write updated config: {}", e);
-                                    }
-                                }
-                            }
-                        }
-
-                        println!(
-                            "✅ Plugin '{}' updated to version '{}'",
-                            publisher_and_name, latest.version
-                        );
-                    } else {
-                        println!(
-                            "Plugin '{}' is already up-to-date (version {})",
-                            publisher_and_name, latest.version
-                        );
-                    }
-                }
-                Err(_) => {
-                    // Fallback: redownload everything
-                    println!(
-                        "No version info for plugin '{}', redownloading to ensure latest.",
-                        publisher_and_name
-                    );
-
-                    let plugin_dir = deva_dir
-                        .join("plugins")
-                        .join(&addon_metadata.publisher)
-                        .join(&addon_metadata.name);
-                    if plugin_dir.exists() {
-                        fs::remove_dir_all(&plugin_dir)
-                            .map_err(|e| format!("Failed to remove old plugin files: {}", e))?;
-                    }
-
-                    download_addon(&publisher_and_name, &addon_metadata).await?;
-
-                    // clear version in config (unknown)
-                    if let Ok(config_path) = path_utils::get_devalang_config_path() {
-                        if let Some(mut config) = load_config(Some(&config_path)) {
-                            if let Some(plugins) = config.plugins.as_mut() {
-                                for p in plugins.iter_mut() {
-                                    let name_in_path = p
-                                        .path
-                                        .strip_prefix("devalang://plugin/")
-                                        .unwrap_or(&p.path);
-                                }
-
-                                if let Err(e) = config.write_config(&config) {
-                                    eprintln!("Warning: failed to write updated config: {}", e);
-                                }
-                            }
-                        }
-                    }
-
-                    println!("✅ Plugin '{}' updated", publisher_and_name);
-                }
-            }
-        }
-
-        devalang_types::AddonType::Preset | devalang_types::AddonType::Template => {
-            println!(
-                "Update for presets/templates is not yet implemented; reinstalling to be safe."
-            );
-            let target_dir = match addon_metadata.addon_type {
-                devalang_types::AddonType::Preset => deva_dir.join("presets"),
-                _ => deva_dir.join("templates"),
-            };
-
-            let candidate = target_dir
-                .join(&addon_metadata.publisher)
-                .join(&addon_metadata.name);
-            if candidate.exists() {
-                fs::remove_dir_all(&candidate)
-                    .map_err(|e| format!("Failed to remove old files: {}", e))?;
-            }
-
-            // use publisher.addon representation for user-facing messaging
-            download_addon(&publisher_and_name, &addon_metadata).await?;
-            println!("✅ Addon '{}' updated (reinstalled)", publisher_and_name);
-        }
-    }
-
-    Ok(())
-}

package/rust/cli/addon/utils.rs

@@ -1,109 +0,0 @@
-use crate::{config::settings::get_user_config, web::forge::get_forge_api_url};
-use devalang_types::AddonType;
-
-pub async fn ask_api_for_signed_url(
-    addon_type: AddonType,
-    publisher: String,
-    slug: &str,
-) -> Result<String, String> {
-    let forge_api_url = get_forge_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());
-    }
-
-    // Build request URL. If publisher is empty, omit the publisher param so the API
-    // can resolve publisher by addon name itself (server-side lookup).
-    let kind = match addon_type {
-        AddonType::Bank => "bank",
-        AddonType::Plugin => "plugin",
-        AddonType::Preset => "preset",
-        AddonType::Template => "template",
-    };
-
-    let request_url = if let Some(token) = &stored_token_opt {
-        if publisher.trim().is_empty() {
-            format!(
-                "{}/v1/addon/url?type={}&slug={}&token={}",
-                forge_api_url, kind, slug, token
-            )
-        } else {
-            format!(
-                "{}/v1/addon/url?type={}&publisher={}&slug={}&token={}",
-                forge_api_url, kind, publisher, slug, token
-            )
-        }
-    } else {
-        if publisher.trim().is_empty() {
-            format!("{}/v1/addon/url?type={}&slug={}", forge_api_url, kind, slug)
-        } else {
-            format!(
-                "{}/v1/addon/url?type={}&publisher={}&slug={}",
-                forge_api_url, kind, publisher, 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)
-    }
-}