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

package/typescript/scripts/version/copy-to-binary.ts

@@ -0,0 +1,82 @@
+import fs from "fs";
+import path from "path";
+
+const argv = process.argv.slice(2);
+let sourceArg: string | undefined;
+let binaryArg: string | undefined;
+let outDirArg: string | undefined;
+
+for (let i = 0; i < argv.length; i++) {
+  const a = argv[i];
+  if (a === "--source") {
+    sourceArg = argv[++i];
+  } else if (a === "--binary") {
+    binaryArg = argv[++i];
+  } else if (a === "--out-dir") {
+    outDirArg = argv[++i];
+  } else if (a === "--help" || a === "-h") {
+    process.exit(0);
+  } else {
+    console.error(`Unknown arg: ${a}`);
+    process.exit(1);
+  }
+}
+
+// Default source: attempt to locate project-version.json at repo root
+const defaultSource = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "project-version.json"
+);
+const sourcePath = sourceArg ? path.resolve(sourceArg) : defaultSource;
+
+if (!fs.existsSync(sourcePath)) {
+  console.error(
+    `Source project-version.json not found at '${sourcePath}'. Please provide --source or ensure file exists.`
+  );
+  process.exit(2);
+}
+
+let destDir: string | null = null;
+
+if (binaryArg) {
+  const binPath = path.resolve(binaryArg);
+  // If it's an existing file, use its directory, otherwise assume user passed target path and use its parent
+  if (fs.existsSync(binPath) && fs.statSync(binPath).isFile()) {
+    destDir = path.dirname(binPath);
+  } else {
+    // If binPath looks like a file path (has extension) use parent, else treat as dir
+    const ext = path.extname(binPath);
+    if (ext) {
+      destDir = path.dirname(binPath);
+    } else {
+      destDir = binPath;
+    }
+  }
+} else if (outDirArg) {
+  destDir = path.resolve(outDirArg);
+} else {
+  // Default: try to copy next to the running node current working dir (useful when packaging)
+  destDir = process.cwd();
+}
+
+if (!destDir) {
+  console.error("Could not resolve destination directory");
+  process.exit(3);
+}
+
+try {
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+
+  const destPath = path.join(destDir, "project-version.json");
+  fs.copyFileSync(sourcePath, destPath);
+  console.log(`project-version.json copied to '${destPath}'`);
+  process.exit(0);
+} catch (err) {
+  console.error("Failed to copy project-version.json:", err);
+  process.exit(4);
+}

package/rust/cli/bank/api.rs

@@ -1,122 +0,0 @@
-use crate::web::cdn::get_cdn_url;
-use devalang_types::{BankFile, BankInfo};
-use serde::Deserialize;
-
-#[derive(Debug, Deserialize)]
-pub struct BankList {
-    pub bank: Vec<BankInfo>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BankVersion {
-    pub version: String,
-}
-
-pub async fn handle_bank_info_command(
-    name: String,
-) -> Result<BankInfo, Box<dyn std::error::Error>> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/{}/info", cdn_url, name);
-
-    let response = reqwest::get(&url).await?;
-
-    if !response.status().is_success() {
-        return Err(format!("Failed to fetch bank info: HTTP {}", response.status()).into());
-    }
-
-    let bytes = response.bytes().await?;
-
-    let parsed: BankInfo = serde_json::from_slice(&bytes)?;
-
-    println!("📦 Bank Info for '{}':", name);
-    println!("  - Name: {}", parsed.name);
-    println!("  - Version: {}", parsed.version);
-    println!("  - Description: {}", parsed.description);
-    println!("  - Author: {}", parsed.author);
-
-    Ok(parsed)
-}
-
-pub async fn fetch_latest_version(
-    bank_name: String,
-) -> Result<BankVersion, Box<dyn std::error::Error>> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/{}/version", cdn_url, bank_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: BankVersion = serde_json::from_slice(&bytes)?;
-
-    Ok(version)
-}
-
-pub async fn list_external_banks() -> Result<Vec<BankInfo>, Box<dyn std::error::Error>> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/list", cdn_url);
-
-    let response = reqwest::get(url).await?;
-
-    if !response.status().is_success() {
-        return Err(format!("❌ Failed to fetch bank list: HTTP {}", response.status()).into());
-    }
-
-    let bytes = response.bytes().await?;
-
-    let parsed: BankList = serde_json::from_slice(&bytes)?;
-
-    Ok(parsed.bank)
-}
-
-pub async fn list_installed_banks() -> Result<Vec<BankFile>, String> {
-    let deva_dir = devalang_utils::path::ensure_deva_dir()?;
-    let bank_dir = deva_dir.join("banks");
-
-    let mut banks = Vec::new();
-
-    if !bank_dir.exists() {
-        return Ok(banks); // No banks installed
-    }
-
-    let config_path = devalang_utils::path::get_devalang_config_path()?;
-    let config = crate::config::ops::load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    let config_banks = config.banks.clone();
-
-    if let Some(banks_in_toml) = config_banks {
-        for bank in banks_in_toml {
-            let bank_name = bank
-                .path
-                .strip_prefix("devalang://bank/")
-                .unwrap_or(&bank.path)
-                .to_string();
-
-            let bank_path = bank_dir.join(&bank_name);
-            if bank_path.exists() {
-                let bank_info_path = bank_path.join("bank.toml");
-
-                if bank_info_path.exists() {
-                    let content = std::fs::read_to_string(&bank_info_path)
-                        .map_err(|e| format!("Failed to read bank info: {}", e))?;
-
-                    match toml::from_str::<BankFile>(&content) {
-                        Ok(bank_info) => banks.push(bank_info),
-                        Err(_err) => {
-                            eprintln!("❌ Error parsing bank info for '{}'", bank_name);
-                        }
-                    }
-                } else {
-                    eprintln!("❌ Bank info file not found for '{}'", bank_name);
-                }
-            }
-        }
-    }
-
-    Ok(banks)
-}

package/rust/cli/bank/commands.rs

@@ -1,306 +0,0 @@
-use crate::cli::install::bank::install_bank;
-use crate::config::ops::load_config;
-use devalang_core::config::driver::ProjectConfigExt;
-use devalang_types::{BankFile, BankInfo};
-use devalang_utils::path as path_utils;
-use std::fs;
-
-pub async fn handle_update_bank_command(name: Option<String>) -> Result<(), String> {
-    let deva_dir = path_utils::ensure_deva_dir()?;
-    let bank_dir = deva_dir.join("banks");
-
-    if !bank_dir.exists() {
-        fs::create_dir_all(bank_dir.clone())
-            .map_err(|e| format!("Failed to create bank directory: {}", e))?;
-    }
-
-    if let Some(name) = name {
-        let bank_path = bank_dir.join(&name);
-        if !bank_path.exists() {
-            return Err(format!("Bank '{}' is not installed", name));
-        }
-
-        // Update specific bank
-        let latest_version = match crate::cli::bank::api::fetch_latest_version(name.clone()).await {
-            Ok(version) => version,
-            Err(err) => {
-                eprintln!("❌ Error fetching latest version for '{}': {}", name, err);
-                return Err(format!("Failed to fetch latest version for '{}'", name));
-            }
-        };
-
-        let local_bank_info_path = bank_path.join("bank.toml");
-        let local_version = match fs::read_to_string(&local_bank_info_path)
-            .ok()
-            .and_then(|content| toml::from_str::<BankFile>(&content).ok())
-            .map(|bf| bf.bank.version)
-        {
-            Some(version) => version,
-            None => {
-                eprintln!(
-                    "⚠️ Unable to read local version for '{}', forcing reinstall...",
-                    name
-                );
-                "".to_string() // Force update
-            }
-        };
-
-        if local_version != latest_version.version {
-            if let Err(e) = update_bank(&name, &latest_version.version).await {
-                eprintln!("❌ Error updating bank '{}': {}", name, e);
-            } else {
-                println!(
-                    "✅ Bank '{}' updated to version '{}'",
-                    name, latest_version.version
-                );
-            }
-        } else {
-            println!(
-                "Bank '{}' is already up-to-date (version {})",
-                name, latest_version.version
-            );
-
-            // Verify if the bank directory exists
-            if !bank_path.exists() {
-                eprintln!(
-                    "❌ Bank directory for '{}' does not exist, reinstalling...",
-                    name
-                );
-                if let Err(e) = install_bank(&name, &deva_dir).await {
-                    eprintln!("❌ Error reinstalling bank '{}': {}", name, e);
-                } else {
-                    println!("✅ Bank '{}' reinstalled successfully!", name);
-                }
-            }
-        }
-    } else {
-        // Update all banks
-        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 config_banks = config.banks.clone();
-
-        if let Some(banks) = config_banks {
-            for bank in banks {
-                let bank_name = bank
-                    .path
-                    .strip_prefix("devalang://bank/")
-                    .unwrap_or(&bank.path)
-                    .to_string();
-
-                let latest_version =
-                    match crate::cli::bank::api::fetch_latest_version(bank_name.clone()).await {
-                        Ok(version) => version,
-                        Err(err) => {
-                            eprintln!(
-                                "❌ Error fetching latest version for '{}': {}",
-                                bank_name, err
-                            );
-                            continue;
-                        }
-                    };
-
-                if let Some(local_bank_version) = bank.version {
-                    if latest_version.version != local_bank_version {
-                        if let Err(e) = update_bank(&bank_name, &latest_version.version).await {
-                            eprintln!("❌ Error updating bank '{}': {}", bank_name, e);
-                        } else {
-                            println!(
-                                "✅ Bank '{}' updated to version '{}'",
-                                bank_name, latest_version.version
-                            );
-                        }
-                    } else {
-                        println!(
-                            "Bank '{}' is already up-to-date (version {})",
-                            bank_name, local_bank_version
-                        );
-
-                        // Verify if the bank directory exists
-                        let bank_path = bank_dir.join(&bank_name);
-
-                        if !bank_path.exists() {
-                            eprintln!(
-                                "❌ Bank directory for '{}' does not exist, reinstalling...",
-                                bank_name
-                            );
-                            if let Err(e) = install_bank(&bank_name, &deva_dir).await {
-                                eprintln!("❌ Error reinstalling bank '{}': {}", bank_name, e);
-                            } else {
-                                println!("✅ Bank '{}' reinstalled successfully!", bank_name);
-                            }
-                        }
-                    }
-                } else {
-                    // If the bank version is not specified in the config, install it
-                    if let Err(e) = install_bank(&bank_name, &deva_dir).await {
-                        eprintln!("❌ Error installing bank '{}': {}", bank_name, e);
-                    } else {
-                        println!("✅ Bank '{}' installed successfully!", bank_name);
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
-
-async fn update_bank(bank_name: &str, _latest_version: &str) -> Result<(), String> {
-    let deva_dir = path_utils::ensure_deva_dir()?;
-
-    // First, delete the existing bank directory
-    let bank_dir = deva_dir.join("banks").join(bank_name);
-
-    if bank_dir.exists() {
-        std::fs::remove_dir_all(&bank_dir).unwrap_or_else(|_| {
-            eprintln!(
-                "⚠️ Failed to remove old bank directory for '{}', aborting !",
-                bank_name
-            );
-            std::process::exit(1);
-        });
-    }
-
-    // Now, install the new version
-    if let Err(e) = install_bank(bank_name, &deva_dir).await {
-        eprintln!("❌ Error installing bank '{}': {}", bank_name, e);
-    } else {
-        println!("✅ Bank '{}' installed successfully!", bank_name);
-    }
-
-    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()))?;
-
-    // Update the bank version in the config
-    if let Some(mut config) = crate::config::ops::load_config(Some(&config_path)) {
-        if let Some(banks) = config.banks.as_mut() {
-            for bank in banks.iter_mut() {
-                if bank
-                    .path
-                    .strip_prefix("devalang://bank/")
-                    .unwrap_or(&bank.path)
-                    == bank_name
-                {
-                    bank.version = Some(_latest_version.to_string());
-                }
-            }
-
-            if let Err(e) = config.write_config(&config) {
-                eprintln!("Warning: failed to write updated config: {}", e);
-            }
-        }
-    }
-
-    Ok(())
-}
-
-pub async fn handle_remove_bank_command(name: String) -> Result<(), String> {
-    let deva_dir = path_utils::ensure_deva_dir()?;
-    let bank_dir = deva_dir.join("banks");
-
-    let bank_path = bank_dir.join(&name);
-
-    if !bank_path.exists() {
-        return Err(format!("Bank '{}' is not installed", name));
-    }
-
-    std::fs::remove_dir_all(&bank_path).map_err(|e| format!("Failed to remove bank: {}", e))?;
-
-    // Remove the bank from 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()))?;
-
-    // Remove the bank from the config
-    if let Some(mut config) = crate::config::ops::load_config(Some(&config_path)) {
-        if let Some(banks) = config.banks.as_mut() {
-            banks.retain(|b| {
-                let name_in_path = b.path.strip_prefix("devalang://bank/").unwrap_or(&b.path);
-                name_in_path != name
-            });
-
-            if let Err(e) = config.write_config(&config) {
-                eprintln!("Warning: failed to write updated config: {}", e);
-            }
-        }
-    }
-
-    println!("✅ Bank '{}' removed successfully", name);
-
-    Ok(())
-}
-
-pub async fn handle_bank_available_command() -> Result<(), String> {
-    let bank_list = match crate::cli::bank::api::list_external_banks().await {
-        Ok(list) => list,
-        Err(_err) => {
-            eprintln!("❌ Error fetching bank list");
-            return Err("Failed to fetch bank list".into());
-        }
-    };
-
-    println!("Available banks for current project :");
-    println!(" ");
-
-    for bank in bank_list {
-        println!("📦 {}", bank.name);
-        println!("   - Version: {}", bank.version);
-        println!("   - Description: {}", bank.description);
-        println!("   - Author: {}", bank.author);
-        println!(" ");
-    }
-
-    Ok(())
-}
-
-pub async fn handle_bank_info_command(
-    name: String,
-) -> Result<BankInfo, Box<dyn std::error::Error>> {
-    crate::cli::bank::api::handle_bank_info_command(name).await
-}
-
-pub async fn handle_bank_list_command() -> Result<(), String> {
-    let bank_list = match crate::cli::bank::api::list_installed_banks().await {
-        Ok(list) => list,
-        Err(_err) => {
-            eprintln!("❌ Error fetching bank list");
-            return Err("Failed to fetch bank list".into());
-        }
-    };
-
-    println!("Installed banks for current project :");
-
-    for bank_toml in bank_list {
-        let latest_version =
-            match crate::cli::bank::api::fetch_latest_version(bank_toml.bank.name.clone()).await {
-                Ok(version) => version,
-                Err(_err) => {
-                    eprintln!(
-                        "❌ Error fetching latest version for '{}'",
-                        bank_toml.bank.name
-                    );
-                    continue;
-                }
-            };
-
-        let is_latest = if latest_version.version == bank_toml.bank.version {
-            "✅"
-        } else {
-            "❗"
-        };
-
-        println!(" ");
-        println!("📦 {}", bank_toml.bank.name);
-        println!(
-            "  - Version: v{} {} (latest: v{})",
-            bank_toml.bank.version, is_latest, latest_version.version
-        );
-        println!("  - Description: {}", bank_toml.bank.description);
-        println!("  - Author: {}", bank_toml.bank.author);
-    }
-
-    Ok(())
-}

package/rust/cli/bank/mod.rs

@@ -1,29 +0,0 @@
-use devalang_types::BankInfo;
-use serde::Deserialize;
-
-pub mod api;
-pub mod commands;
-
-#[derive(Debug, Deserialize)]
-pub struct BankList {
-    pub bank: Vec<BankInfo>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BankInfoFetched {
-    pub name: String,
-    pub version: String,
-    pub description: String,
-    pub author: String,
-    pub latest_version: String,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BankVersion {
-    pub version: String,
-}
-
-pub use commands::{
-    handle_bank_available_command, handle_bank_info_command, handle_bank_list_command,
-    handle_remove_bank_command, handle_update_bank_command,
-};

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;