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

package/rust/types/src/config.rs

@@ -1,4 +1,4 @@
-use serde::{Deserialize, Serialize};
+use serde::{ Deserialize, Serialize };
 use toml::Value as TomlValue;
 
 use crate::TelemetrySettings;
@@ -57,13 +57,11 @@ pub struct ProjectConfigDefaults {
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
 pub struct ProjectConfigBankEntry {
     pub path: String,
-    pub version: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
 pub struct ProjectConfigPluginEntry {
     pub path: String,
-    pub version: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]

package/rust/utils/Cargo.toml

@@ -1,18 +1,21 @@
 [package]
 name = "devalang_utils"
-version = "0.0.2"
+version = "0.0.3"
 description = "Utility functions and types for Devalang"
 license = "MIT"
 authors = ["Devaloop <contact@devaloop.com>"]
 edition = "2024"
 
 [dependencies]
-devalang_types = { path = "../types", version = "0.0.3" }
+devalang_types = { path = "../types", version = "0.0.4" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 include_dir = "0.7"
 notify = "6.1"
 zip = "4.3.0"
+flate2 = "1.0"
+tar = "0.4"
+tempfile = "3"
 
 [dependencies.crossterm]
 version = "0.27"

package/rust/utils/src/file.rs

@@ -1,5 +1,5 @@
-use include_dir::{Dir, DirEntry};
-use std::{fs, path::Path};
+use include_dir::{ Dir, DirEntry };
+use std::{ fs, path::Path, io::{ Read, Seek, SeekFrom } };
 
 pub fn copy_dir_recursive(dir: &Dir, target_root: &Path, base_path: &Path) {
     for entry in dir.entries() {
@@ -56,39 +56,422 @@ pub fn format_file_size(bytes: u64) -> String {
 }
 
 pub fn extract_zip_safely(archive_path: &Path, dest: &Path) -> Result<(), String> {
-    let file = std::fs::File::open(archive_path)
+    // Open file and peek magic bytes to determine archive format
+    let mut file = std::fs::File
+        ::open(archive_path)
         .map_err(|e| format!("Failed to open archive {}: {}", archive_path.display(), e))?;
-    let mut archive = zip::ZipArchive::new(file)
-        .map_err(|e| format!("Failed to read archive {}: {}", archive_path.display(), e))?;
 
+    let mut magic = [0u8; 4];
+    let n = file
+        .read(&mut magic)
+        .map_err(|e| format!("Failed to read archive header {}: {}", archive_path.display(), e))?;
+    file
+        .seek(SeekFrom::Start(0))
+        .map_err(|e| format!("Failed to seek archive {}: {}", archive_path.display(), e))?;
+
+    let is_gzip = n >= 2 && magic[0] == 0x1f && magic[1] == 0x8b;
+    let is_zip = n >= 2 && magic[0] == 0x50 && magic[1] == 0x4b;
+
+    if is_gzip {
+        // The gzip may contain a tar archive OR a gzipped zip (PK inside).
+        // Decompress to a temporary file, inspect its magic bytes, then choose extractor.
+        let mut gz = flate2::read::GzDecoder::new(file);
+
+        let mut named = tempfile::NamedTempFile
+            ::new()
+            .map_err(|e| format!("Failed to create temp file: {}", e))?;
+
+        std::io
+            ::copy(&mut gz, &mut named)
+            .map_err(|e| format!("Failed to decompress gzip to temp: {}", e))?;
+        named
+            .as_file_mut()
+            .seek(SeekFrom::Start(0))
+            .map_err(|e| format!("Failed to seek temp file: {}", e))?;
+
+        // Read magic of decompressed content
+        let mut head = [0u8; 4];
+        let n = named
+            .as_file_mut()
+            .read(&mut head)
+            .map_err(|e| format!("Failed to read temp archive header: {}", e))?;
+        named
+            .as_file_mut()
+            .seek(SeekFrom::Start(0))
+            .map_err(|e| format!("Failed to rewind temp file: {}", e))?;
+
+        let inner_is_zip = n >= 2 && head[0] == 0x50 && head[1] == 0x4b;
+
+        if inner_is_zip {
+            let tmp_file = named
+                .reopen()
+                .map_err(|e| format!("Failed to reopen temp file for zip: {}", e))?;
+
+            let mut archive = zip::ZipArchive
+                ::new(tmp_file)
+                .map_err(|e| format!("Failed to read zip archive inside gzip: {}", e))?;
+
+            for i in 0..archive.len() {
+                let mut file = archive
+                    .by_index(i)
+                    .map_err(|e| format!("Failed to access zip archive entry {}: {}", i, e))?;
+                let enclosed = match file.enclosed_name() {
+                    Some(p) => p.to_owned(),
+                    None => {
+                        continue;
+                    }
+                };
+                if
+                    enclosed.is_absolute() ||
+                    enclosed.components().any(|c| matches!(c, std::path::Component::ParentDir))
+                {
+                    continue;
+                }
+                let outpath = dest.join(enclosed);
+                if file.name().ends_with('/') || file.is_dir() {
+                    std::fs
+                        ::create_dir_all(&outpath)
+                        .map_err(|e| format!("Failed to create dir {}: {}", outpath.display(), e))?;
+                } else {
+                    if let Some(p) = outpath.parent() {
+                        std::fs
+                            ::create_dir_all(p)
+                            .map_err(|e|
+                                format!("Failed to create parent {}: {}", p.display(), e)
+                            )?;
+                    }
+                    let mut outfile = std::fs::File
+                        ::create(&outpath)
+                        .map_err(|e|
+                            format!("Failed to create file {}: {}", outpath.display(), e)
+                        )?;
+                    std::io
+                        ::copy(&mut file, &mut outfile)
+                        .map_err(|e| format!("Failed to write file {}: {}", outpath.display(), e))?;
+                }
+            }
+
+            // NamedTempFile will be removed on drop
+            return Ok(());
+        }
+
+        // otherwise treat as tar
+        let tmp_file = named
+            .reopen()
+            .map_err(|e| format!("Failed to reopen temp file for tar: {}", e))?;
+        let mut archive = tar::Archive::new(tmp_file);
+
+        for entry in archive
+            .entries()
+            .map_err(|e| format!("Failed to read tar entries (from gzip): {}", e))? {
+            let mut entry = entry.map_err(|e|
+                format!("Failed to read tar archive entry (from gzip): {}", e)
+            )?;
+            let path = match entry.path() {
+                Ok(p) => p.into_owned(),
+                Err(_) => {
+                    continue;
+                }
+            };
+            if
+                path.is_absolute() ||
+                path.components().any(|c| matches!(c, std::path::Component::ParentDir))
+            {
+                continue;
+            }
+            let outpath = dest.join(&path);
+            if let Some(parent) = outpath.parent() {
+                std::fs
+                    ::create_dir_all(parent)
+                    .map_err(|e| format!("Failed to create parent {}: {}", parent.display(), e))?;
+            }
+            entry
+                .unpack(&outpath)
+                .map_err(|e|
+                    format!("Failed to unpack tar entry to {}: {}", outpath.display(), e)
+                )?;
+        }
+
+        return Ok(());
+    }
+
+    if is_zip {
+        // Re-open file for zip
+        let file = std::fs::File
+            ::open(archive_path)
+            .map_err(|e|
+                format!("Failed to open archive for zip {}: {}", archive_path.display(), e)
+            )?;
+
+        let mut archive = zip::ZipArchive
+            ::new(file)
+            .map_err(|e| format!("Failed to read zip archive {}: {}", archive_path.display(), e))?;
+
+        for i in 0..archive.len() {
+            let mut file = archive
+                .by_index(i)
+                .map_err(|e| format!("Failed to access zip archive entry {}: {}", i, e))?;
+
+            let enclosed = match file.enclosed_name() {
+                Some(p) => p.to_owned(),
+                None => {
+                    continue;
+                }
+            };
+
+            if
+                enclosed.is_absolute() ||
+                enclosed.components().any(|c| matches!(c, std::path::Component::ParentDir))
+            {
+                continue;
+            }
+
+            let outpath = dest.join(enclosed);
+            if file.name().ends_with('/') || file.is_dir() {
+                std::fs
+                    ::create_dir_all(&outpath)
+                    .map_err(|e| format!("Failed to create dir {}: {}", outpath.display(), e))?;
+            } else {
+                if let Some(p) = outpath.parent() {
+                    std::fs
+                        ::create_dir_all(p)
+                        .map_err(|e| format!("Failed to create parent {}: {}", p.display(), e))?;
+                }
+                let mut outfile = std::fs::File
+                    ::create(&outpath)
+                    .map_err(|e| format!("Failed to create file {}: {}", outpath.display(), e))?;
+                std::io
+                    ::copy(&mut file, &mut outfile)
+                    .map_err(|e| format!("Failed to write file {}: {}", outpath.display(), e))?;
+            }
+        }
+
+        return Ok(());
+    }
+
+    // Unknown magic: try tar.gz first, then zip as fallback
+    // Try tar.gz
+    let file = std::fs::File
+        ::open(archive_path)
+        .map_err(|e| format!("Failed to open archive {}: {}", archive_path.display(), e))?;
+    if
+        let Ok(()) = (|| -> Result<(), String> {
+            let gz = flate2::read::GzDecoder::new(&file);
+            let mut archive = tar::Archive::new(gz);
+            for entry in archive
+                .entries()
+                .map_err(|e| format!("Failed to read tar entries: {}", e))? {
+                let mut entry = entry.map_err(|e|
+                    format!("Failed to read tar archive entry: {}", e)
+                )?;
+                let path = match entry.path() {
+                    Ok(p) => p.into_owned(),
+                    Err(_) => {
+                        continue;
+                    }
+                };
+                if
+                    path.is_absolute() ||
+                    path.components().any(|c| matches!(c, std::path::Component::ParentDir))
+                {
+                    continue;
+                }
+                let outpath = dest.join(&path);
+                if let Some(parent) = outpath.parent() {
+                    std::fs
+                        ::create_dir_all(parent)
+                        .map_err(|e|
+                            format!("Failed to create parent {}: {}", parent.display(), e)
+                        )?;
+                }
+                entry
+                    .unpack(&outpath)
+                    .map_err(|e|
+                        format!("Failed to unpack tar entry to {}: {}", outpath.display(), e)
+                    )?;
+            }
+            Ok(())
+        })()
+    {
+        return Ok(());
+    }
+
+    // Fallback to zip
+    let file = std::fs::File
+        ::open(archive_path)
+        .map_err(|e| format!("Failed to open archive for zip {}: {}", archive_path.display(), e))?;
+    let mut archive = zip::ZipArchive
+        ::new(file)
+        .map_err(|e| format!("Failed to read zip archive {}: {}", archive_path.display(), e))?;
     for i in 0..archive.len() {
         let mut file = archive
             .by_index(i)
-            .map_err(|e| format!("Failed to access archive entry {}: {}", i, e))?;
-
+            .map_err(|e| format!("Failed to access zip archive entry {}: {}", i, e))?;
         let enclosed = match file.enclosed_name() {
-            Some(path) => path.to_owned(),
+            Some(p) => p.to_owned(),
             None => {
                 continue;
             }
         };
-
+        if
+            enclosed.is_absolute() ||
+            enclosed.components().any(|c| matches!(c, std::path::Component::ParentDir))
+        {
+            continue;
+        }
         let outpath = dest.join(enclosed);
-
         if file.name().ends_with('/') || file.is_dir() {
-            std::fs::create_dir_all(&outpath)
+            std::fs
+                ::create_dir_all(&outpath)
                 .map_err(|e| format!("Failed to create dir {}: {}", outpath.display(), e))?;
         } else {
             if let Some(p) = outpath.parent() {
-                std::fs::create_dir_all(p)
+                std::fs
+                    ::create_dir_all(p)
                     .map_err(|e| format!("Failed to create parent {}: {}", p.display(), e))?;
             }
-            let mut outfile = std::fs::File::create(&outpath)
+            let mut outfile = std::fs::File
+                ::create(&outpath)
                 .map_err(|e| format!("Failed to create file {}: {}", outpath.display(), e))?;
-            std::io::copy(&mut file, &mut outfile)
+            std::io
+                ::copy(&mut file, &mut outfile)
                 .map_err(|e| format!("Failed to write file {}: {}", outpath.display(), e))?;
         }
     }
 
     Ok(())
 }
+
+/// Detects addon type by inspecting archive contents without extracting fully.
+/// Returns one of: "bank", "plugin", "preset", "template", or "unknown".
+pub fn detect_addon_type_in_archive(archive_path: &Path) -> Result<String, String> {
+    use std::fs::File;
+
+    let mut file = File::open(archive_path)
+        .map_err(|e| format!("Failed to open archive {}: {}", archive_path.display(), e))?;
+
+    let mut magic = [0u8; 4];
+    let n = file
+        .read(&mut magic)
+        .map_err(|e| format!("Failed to read archive header {}: {}", archive_path.display(), e))?;
+    file
+        .seek(SeekFrom::Start(0))
+        .map_err(|e| format!("Failed to seek archive {}: {}", archive_path.display(), e))?;
+
+    let is_gzip = n >= 2 && magic[0] == 0x1f && magic[1] == 0x8b;
+    let is_zip = n >= 2 && magic[0] == 0x50 && magic[1] == 0x4b;
+
+    let check_name = |name: &str| {
+        let lname = name.to_ascii_lowercase();
+        if lname.ends_with("bank.toml") {
+            return Some("bank".to_string());
+        }
+        if lname.ends_with("plugin.toml") {
+            return Some("plugin".to_string());
+        }
+        if lname.ends_with("preset.toml") {
+            return Some("preset".to_string());
+        }
+        if lname.ends_with("template.toml") {
+            return Some("template".to_string());
+        }
+        None
+    };
+
+    if is_gzip {
+        // Decompress to temp and inspect inner archive
+        let mut gz = flate2::read::GzDecoder::new(file);
+        let mut named = tempfile::NamedTempFile::new()
+            .map_err(|e| format!("Failed to create temp file: {}", e))?;
+        std::io::copy(&mut gz, &mut named)
+            .map_err(|e| format!("Failed to decompress gzip to temp: {}", e))?;
+        named.as_file_mut().seek(SeekFrom::Start(0)).map_err(|e| format!("Failed to seek temp file: {}", e))?;
+
+        // Inspect inner magic
+        let mut head = [0u8; 4];
+        let m = named.as_file_mut().read(&mut head).map_err(|e| format!("Failed to read temp archive header: {}", e))?;
+        named.as_file_mut().seek(SeekFrom::Start(0)).map_err(|e| format!("Failed to rewind temp file: {}", e))?;
+
+        let inner_is_zip = m >= 2 && head[0] == 0x50 && head[1] == 0x4b;
+        if inner_is_zip {
+            let tmp_file = named.reopen().map_err(|e| format!("Failed to reopen temp file for zip: {}", e))?;
+            let mut archive = zip::ZipArchive::new(tmp_file).map_err(|e| format!("Failed to read zip archive inside gzip: {}", e))?;
+            for i in 0..archive.len() {
+                if let Ok(file) = archive.by_index(i) {
+                    if let Some(enclosed) = file.enclosed_name() {
+                        let s = enclosed.to_string_lossy().to_string();
+                        if let Some(t) = check_name(&s) {
+                            return Ok(t);
+                        }
+                    }
+                }
+            }
+            return Ok("unknown".to_string());
+        }
+
+        // treat as tar
+        let tmp_file = named.reopen().map_err(|e| format!("Failed to reopen temp file for tar: {}", e))?;
+        let mut archive = tar::Archive::new(tmp_file);
+        if let Ok(entries) = archive.entries() {
+            for entry in entries.filter_map(|e| e.ok()) {
+                if let Ok(path) = entry.path() {
+                    let s = path.to_string_lossy().to_string();
+                    if let Some(t) = check_name(&s) {
+                        return Ok(t);
+                    }
+                }
+            }
+        }
+        return Ok("unknown".to_string());
+    }
+
+    if is_zip {
+        let file = std::fs::File::open(archive_path).map_err(|e| format!("Failed to open archive for zip {}: {}", archive_path.display(), e))?;
+        let mut archive = zip::ZipArchive::new(file).map_err(|e| format!("Failed to read zip archive {}: {}", archive_path.display(), e))?;
+        for i in 0..archive.len() {
+            if let Ok(file) = archive.by_index(i) {
+                if let Some(enclosed) = file.enclosed_name() {
+                    let s = enclosed.to_string_lossy().to_string();
+                    if let Some(t) = check_name(&s) {
+                        return Ok(t);
+                    }
+                }
+            }
+        }
+        return Ok("unknown".to_string());
+    }
+
+    // fallback: try tar.gz read attempt
+    if let Ok(f) = std::fs::File::open(archive_path) {
+        let gz = flate2::read::GzDecoder::new(f);
+        let mut archive = tar::Archive::new(gz);
+        if let Ok(entries) = archive.entries() {
+            for entry in entries.filter_map(|e| e.ok()) {
+                if let Ok(path) = entry.path() {
+                    let s = path.to_string_lossy().to_string();
+                    if let Some(t) = check_name(&s) {
+                        return Ok(t);
+                    }
+                }
+            }
+        }
+    }
+
+    Ok("unknown".to_string())
+}
+
+/// Removes the temporary folder located at `.deva/tmp` inside the project root if it exists.
+/// Returns Ok(()) even if the folder did not exist. Returns Err(String) on filesystem errors.
+pub fn clear_tmp_folder() -> Result<(), String> {
+    match crate::path::ensure_deva_dir() {
+        Ok(deva_dir) => {
+            let tmp_dir = deva_dir.join("tmp");
+            if tmp_dir.exists() {
+                std::fs::remove_dir_all(&tmp_dir)
+                    .map_err(|e| format!("Failed to remove tmp dir '{}': {}", tmp_dir.display(), e))?;
+            }
+            Ok(())
+        }
+        Err(e) => Err(e),
+    }
+}

package/rust/utils/src/path.rs

@@ -43,8 +43,37 @@ pub fn find_project_root() -> Option<PathBuf> {
 
 /// Finds the package root using the `CARGO_MANIFEST_DIR` env var set by Cargo.
 pub fn get_package_root() -> Option<PathBuf> {
-    let cargo_dir = env::var("CARGO_MANIFEST_DIR").ok()?;
-    Some(PathBuf::from(cargo_dir))
+    // Prefer Cargo-provided manifest dir when available (build-time / cargo run)
+    if let Ok(cargo_dir) = env::var("CARGO_MANIFEST_DIR") {
+        let p = PathBuf::from(cargo_dir);
+        if p.exists() {
+            return Some(p);
+        }
+    }
+
+    // At runtime (packaged binary) try to infer the package root from the
+    // binary location: walk upward from the running executable and look for
+    // common markers (package.json, project-version.json, Cargo.toml).
+    if let Ok(exe_path) = env::current_exe() {
+        if let Some(mut dir) = exe_path.parent().map(|p| p.to_path_buf()) {
+            loop {
+                if dir.join("package.json").exists()
+                    || dir.join("project-version.json").exists()
+                    || dir.join("Cargo.toml").exists()
+                {
+                    return Some(dir);
+                }
+
+                if let Some(parent) = dir.parent() {
+                    dir = parent.to_path_buf();
+                } else {
+                    break;
+                }
+            }
+        }
+    }
+
+    None
 }
 
 /// Gets the project root or returns a descriptive error if not found.

package/rust/utils/src/version.rs

@@ -1,20 +1,51 @@
 use crate::{ path::get_package_root, signature::get_signature };
 
+/// Returns the CLI version with a runtime-first strategy:
+/// 1. DEVALANG_CLI_VERSION env var
+/// 2. project-version.json located next to the running binary
+/// 3. package.json located in the package root
+/// 4. compile-time env!("CARGO_PKG_VERSION") as a last resort
 pub fn get_version() -> String {
+    // 1) env override
+    if let Ok(v) = std::env::var("DEVALANG_CLI_VERSION") {
+        if !v.trim().is_empty() {
+            return v;
+        }
+    }
+
+    // 2) project-version.json next to binary
+    if let Ok(exe) = std::env::current_exe() {
+        if let Some(bin_dir) = exe.parent() {
+            let pv = bin_dir.join("project-version.json");
+            if pv.exists() {
+                if let Ok(contents) = std::fs::read_to_string(pv) {
+                    if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&contents) {
+                        if let Some(v) = parsed.get("version").and_then(|s| s.as_str()) {
+                            return v.to_string();
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // 3) package.json via package root
     if let Some(root) = get_package_root() {
-        let project_version_json = root.join("package.json");
-        if let Ok(version) = std::fs::read_to_string(project_version_json) {
-            if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&version) {
-                if let Some(version_val) = parsed.get("version") {
-                    if let Some(s) = version_val.as_str() {
-                        return s.to_string();
+        let pkg = root.join("package.json");
+        if pkg.exists() {
+            if let Ok(contents) = std::fs::read_to_string(pkg) {
+                if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&contents) {
+                    if let Some(v) = parsed.get("version").and_then(|s| s.as_str()) {
+                        return v.to_string();
                     }
                 }
             }
         }
     }
 
-    "0.0.0".to_string()
+    // 4) compile-time fallback
+    let compile_time = option_env!("CARGO_PKG_VERSION").unwrap_or("0.0.0");
+    compile_time.to_string()
 }
 
 pub fn get_version_with_signature() -> String {

package/rust/web/auth.rs

@@ -0,0 +1,5 @@
+pub fn get_auth_url() -> String {
+    let auth_url = "https://auth.devalang.com";
+    // let auth_url = "http://127.0.0.1:8787";
+    auth_url.to_string()
+}

package/rust/web/forge.rs

@@ -0,0 +1,5 @@
+pub fn get_forge_api_url() -> String {
+    let forge_url = "https://forge.devalang.com";
+    // let forge_url = "http://127.0.0.1:9090";
+    forge_url.to_string()
+}

package/rust/web/mod.rs

@@ -1,3 +1,5 @@
-pub mod api;
-pub mod cdn;
-pub mod sso;
+pub mod api;
+pub mod auth;
+pub mod cdn;
+pub mod forge;
+pub mod sso;