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

package/rust/cli/discover/config.rs

@@ -1,111 +1,109 @@
-use devalang_core::config::driver::ProjectConfigExt;
-use devalang_types::{AddonWithMetadata, ProjectConfigBankEntry, ProjectConfigPluginEntry};
-use devalang_utils::path as path_utils;
-
-pub async fn add_addons_to_config(addons: Vec<AddonWithMetadata>) -> Result<(), String> {
-    let config_path = path_utils::get_devalang_config_path()?;
-    let mut config = crate::config::ops::load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    for addon in addons {
-        let addon_path_as_devalang_protocol = format!(
-            "devalang://{}/{}.{}",
-            addon.addon_type, addon.metadata.author, addon.metadata.name
-        );
-
-        match addon.addon_type.as_str() {
-            "bank" => {
-                if config.banks.is_none() {
-                    config.banks = Some(Vec::new());
-                }
-
-                let banks = config.banks.as_mut().unwrap();
-
-                let exists = banks
-                    .iter()
-                    .any(|b| b.path == addon_path_as_devalang_protocol);
-                if exists {
-                    println!("Bank '{}' already in config", addon.name);
-                    continue;
-                }
-
-                banks.push(ProjectConfigBankEntry {
-                    path: addon_path_as_devalang_protocol,
-                    version: Some(addon.metadata.version.clone()),
-                });
-            }
-
-            "plugin" => {
-                if config.plugins.is_none() {
-                    config.plugins = Some(Vec::new());
-                }
-
-                let plugins = config.plugins.as_mut().unwrap();
-
-                let exists = plugins
-                    .iter()
-                    .any(|p| p.path == addon_path_as_devalang_protocol);
-                if exists {
-                    println!("Plugin '{}' already in config", addon.name);
-                    continue;
-                }
-
-                plugins.push(ProjectConfigPluginEntry {
-                    path: addon_path_as_devalang_protocol,
-                    version: Some(addon.metadata.version.clone()),
-                });
-            }
-
-            // "preset" => {
-            //     if config.presets.is_none() {
-            //         config.presets = Some(Vec::new());
-            //     }
-
-            //     let presets = config.presets.as_mut().unwrap();
-
-            //     let exists = presets.iter().any(|p| p.path == addon_path_as_deva_protocol);
-            //     if exists {
-            //         println!("Preset '{}' already in config", addon.name);
-            //         continue;
-            //     }
-
-            //     presets.push(ProjectConfigPresetEntry {
-            //         path: addon_path_as_deva_protocol,
-            //         version: Some(addon.metadata.version.clone()),
-            //     });
-            // }
-
-            // "template" => {
-            //     if config.templates.is_none() {
-            //         config.templates = Some(Vec::new());
-            //     }
-
-            //     let templates = config.templates.as_mut().unwrap();
-
-            //     let exists = templates.iter().any(|t| t.path == addon_path_as_deva_protocol);
-            //     if exists {
-            //         println!("Template '{}' already in config", addon.name);
-            //         continue;
-            //     }
-
-            //     templates.push(ProjectConfigTemplateEntry {
-            //         path: addon_path_as_deva_protocol,
-            //         version: Some(addon.metadata.version.clone()),
-            //     });
-            // }
-            _ => {
-                println!(
-                    "Unknown addon type '{}' for addon '{}'",
-                    addon.addon_type, addon.name
-                );
-            }
-        }
-    }
-
-    // Update config with new addons
-    if let Err(e) = config.write_config(&config) {
-        return Err(format!("Failed to write config: {}", e));
-    }
-
-    Ok(())
-}
+use devalang_core::config::driver::ProjectConfigExt;
+use devalang_types::{AddonWithMetadata, ProjectConfigBankEntry, ProjectConfigPluginEntry};
+use devalang_utils::path as path_utils;
+
+pub async fn add_addons_to_config(addons: Vec<AddonWithMetadata>) -> Result<(), String> {
+    let config_path = path_utils::get_devalang_config_path()?;
+    let mut config = crate::config::ops::load_config(Some(&config_path))
+        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
+
+    for addon in addons {
+        let addon_path_as_devalang_protocol = format!(
+            "devalang://{}/{}/{}",
+            addon.addon_type, addon.metadata.publisher, addon.metadata.name
+        );
+
+        match addon.addon_type.as_str() {
+            "bank" => {
+                if config.banks.is_none() {
+                    config.banks = Some(Vec::new());
+                }
+
+                let banks = config.banks.as_mut().unwrap();
+
+                let exists = banks
+                    .iter()
+                    .any(|b| b.path == addon_path_as_devalang_protocol);
+                if exists {
+                    println!("Bank '{}' already in config", addon.name);
+                    continue;
+                }
+
+                banks.push(ProjectConfigBankEntry {
+                    path: addon_path_as_devalang_protocol,
+                });
+            }
+
+            "plugin" => {
+                if config.plugins.is_none() {
+                    config.plugins = Some(Vec::new());
+                }
+
+                let plugins = config.plugins.as_mut().unwrap();
+
+                let exists = plugins
+                    .iter()
+                    .any(|p| p.path == addon_path_as_devalang_protocol);
+                if exists {
+                    println!("Plugin '{}' already in config", addon.name);
+                    continue;
+                }
+
+                plugins.push(ProjectConfigPluginEntry {
+                    path: addon_path_as_devalang_protocol,
+                });
+            }
+
+            // "preset" => {
+            //     if config.presets.is_none() {
+            //         config.presets = Some(Vec::new());
+            //     }
+
+            //     let presets = config.presets.as_mut().unwrap();
+
+            //     let exists = presets.iter().any(|p| p.path == addon_path_as_deva_protocol);
+            //     if exists {
+            //         println!("Preset '{}' already in config", addon.name);
+            //         continue;
+            //     }
+
+            //     presets.push(ProjectConfigPresetEntry {
+            //         path: addon_path_as_deva_protocol,
+            //         version: Some(addon.metadata.version.clone()),
+            //     });
+            // }
+
+            // "template" => {
+            //     if config.templates.is_none() {
+            //         config.templates = Some(Vec::new());
+            //     }
+
+            //     let templates = config.templates.as_mut().unwrap();
+
+            //     let exists = templates.iter().any(|t| t.path == addon_path_as_deva_protocol);
+            //     if exists {
+            //         println!("Template '{}' already in config", addon.name);
+            //         continue;
+            //     }
+
+            //     templates.push(ProjectConfigTemplateEntry {
+            //         path: addon_path_as_deva_protocol,
+            //         version: Some(addon.metadata.version.clone()),
+            //     });
+            // }
+            _ => {
+                println!(
+                    "Unknown addon type '{}' for addon '{}'",
+                    addon.addon_type, addon.name
+                );
+            }
+        }
+    }
+
+    // Update config with new addons
+    if let Err(e) = config.write_config(&config) {
+        return Err(format!("Failed to write config: {}", e));
+    }
+
+    Ok(())
+}

package/rust/cli/discover/fs.rs

@@ -1,19 +1,19 @@
-use std::{fs, io, path::Path};
-
-pub fn copy_dir_all(src: &Path, dst: &Path) -> Result<(), io::Error> {
-    if !dst.exists() {
-        fs::create_dir_all(dst)?;
-    }
-    for entry in fs::read_dir(src)? {
-        let entry = entry?;
-        let ty = entry.file_type()?;
-        let from = entry.path();
-        let to = dst.join(entry.file_name());
-        if ty.is_dir() {
-            copy_dir_all(&from, &to)?;
-        } else {
-            fs::copy(&from, &to)?;
-        }
-    }
-    Ok(())
-}
+use std::{fs, io, path::Path};
+
+pub fn copy_dir_all(src: &Path, dst: &Path) -> Result<(), io::Error> {
+    if !dst.exists() {
+        fs::create_dir_all(dst)?;
+    }
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        let from = entry.path();
+        let to = dst.join(entry.file_name());
+        if ty.is_dir() {
+            copy_dir_all(&from, &to)?;
+        } else {
+            fs::copy(&from, &to)?;
+        }
+    }
+    Ok(())
+}

package/rust/cli/discover/install.rs

@@ -1,103 +1,214 @@
-use devalang_types::{AddonMetadata, AddonWithMetadata, DiscoveredAddon};
-use devalang_utils::path as path_utils;
-
-pub async fn install_selected_addons(
-    addons: Vec<DiscoveredAddon>,
-) -> Result<Vec<AddonWithMetadata>, String> {
-    let mut addons_enriched = Vec::new();
-
-    let tmp_dir = path_utils::ensure_deva_dir()?.join("tmp");
-
-    for addon in addons {
-        std::fs::create_dir_all(tmp_dir.join(&addon.name))
-            .map_err(|e| format!("Failed to create directory for addon {}: {}", addon.name, e))?;
-
-        let addon_path = tmp_dir.join(&addon.name);
-        devalang_utils::file::extract_zip_safely(&addon.path, &addon_path)
-            .map_err(|e| format!("Failed to extract addon {}: {}", addon.name, e))?;
-
-        let base = path_utils::ensure_deva_dir()?;
-        let target_addon_dir = match addon.addon_type.as_str() {
-            "bank" => base.join("banks"),
-            "plugin" => base.join("plugins"),
-            "preset" => base.join("presets"),
-            "template" => base.join("templates"),
-            _ => {
-                return Err(format!("Unknown addon type for addon {}", addon.name));
-            }
-        };
-
-        std::fs::create_dir_all(&target_addon_dir).map_err(|e| {
-            format!(
-                "Failed to create target directory for addon {}: {}",
-                addon.name, e
-            )
-        })?;
-
-        let target_addon_path_dir = target_addon_dir.join(&addon.name);
-        if target_addon_path_dir.exists() {
-            println!(
-                "Target addon directory {} already exists",
-                target_addon_path_dir.display()
-            );
-            continue;
-        }
-
-        if let Err(e) = std::fs::rename(&addon_path, &target_addon_path_dir) {
-            crate::cli::discover::fs::copy_dir_all(&addon_path, &target_addon_path_dir).map_err(
-                |err| {
-                    format!(
-                        "Failed to move addon {}: {} (rename error: {})",
-                        addon.name, err, e
-                    )
-                },
-            )?;
-            let _ = std::fs::remove_dir_all(&addon_path);
-        }
-
-        let addon_metadata_filename = match addon.addon_type.as_str() {
-            "bank" => "bank.toml",
-            "plugin" => "plugin.toml",
-            "preset" => "preset.toml",
-            "template" => "template.toml",
-            _ => {
-                return Err(format!("Unknown addon type for addon {}", addon.name));
-            }
-        };
-
-        let addon_metadata_path = target_addon_path_dir.join(addon_metadata_filename);
-        let addon_metadata_content = std::fs::read_to_string(&addon_metadata_path)
-            .map_err(|e| format!("Failed to read metadata for addon {}: {}", addon.name, e))?;
-
-        let parsed_meta = crate::cli::discover::metadata::parse_metadata_file(
-            &addon.addon_type,
-            &addon_metadata_content,
-        )
-        .unwrap_or(AddonMetadata {
-            name: addon.name.clone(),
-            author: "unknown".to_string(),
-            version: "".to_string(),
-            description: "".to_string(),
-            access: "".to_string(),
-        });
-
-        addons_enriched.push(AddonWithMetadata {
-            name: addon.name.clone(),
-            path: addon.path.clone().to_string_lossy().to_string(),
-            addon_type: addon.addon_type.clone(),
-            metadata: parsed_meta,
-        });
-
-        if let Err(e) = std::fs::remove_file(&addon.path) {
-            eprintln!(
-                "Failed to remove zipped file for addon {}: {}",
-                addon.name, e
-            );
-        }
-    }
-
-    // Best-effort cleanup of temporary extraction directory
-    let _ = std::fs::remove_dir_all(&tmp_dir);
-
-    Ok(addons_enriched)
-}
+use devalang_types::{AddonMetadata, AddonWithMetadata, DiscoveredAddon};
+use devalang_utils::path as path_utils;
+
+pub async fn install_selected_addons(
+    addons: Vec<DiscoveredAddon>,
+    no_clear_tmp: bool,
+) -> Result<Vec<AddonWithMetadata>, String> {
+    let mut addons_enriched = Vec::new();
+
+    let tmp_dir = path_utils::ensure_deva_dir()?.join("tmp");
+
+    for addon in addons {
+        std::fs::create_dir_all(tmp_dir.join(&addon.name))
+            .map_err(|e| format!("Failed to create directory for addon {}: {}", addon.name, e))?;
+
+        let addon_path = tmp_dir.join(&addon.name);
+        devalang_utils::file::extract_zip_safely(&addon.path, &addon_path)
+            .map_err(|e| format!("Failed to extract addon {}: {}", addon.name, e))?;
+
+        // Read metadata from the extracted addon first so we can layout as <publisher>/<name>
+        // If the addon type is unknown (we found a .tar.gz), try to detect the
+        // metadata file inside the extracted folder to discover the real type.
+        let mut detected_addon_type = addon.addon_type.clone();
+        let mut parsed_meta_tmp = None;
+
+        if detected_addon_type == "unknown" {
+            // try detection by checking common metadata filenames
+            let candidates = ["bank.toml", "plugin.toml", "preset.toml", "template.toml"];
+            for candidate in &candidates {
+                let path = addon_path.join(candidate);
+                if path.exists() {
+                    detected_addon_type = match *candidate {
+                        "bank.toml" => "bank".to_string(),
+                        "plugin.toml" => "plugin".to_string(),
+                        "preset.toml" => "preset".to_string(),
+                        "template.toml" => "template".to_string(),
+                        _ => "unknown".to_string(),
+                    };
+                    if let Ok(content) = std::fs::read_to_string(&path) {
+                        parsed_meta_tmp = crate::cli::discover::metadata::parse_metadata_file(
+                            &detected_addon_type,
+                            &content,
+                        );
+                    }
+                    break;
+                }
+            }
+        } else {
+            let addon_metadata_filename = match addon.addon_type.as_str() {
+                "bank" => "bank.toml",
+                "plugin" => "plugin.toml",
+                "preset" => "preset.toml",
+                "template" => "template.toml",
+                _ => "",
+            };
+            if !addon_metadata_filename.is_empty() {
+                let addon_metadata_path_tmp = addon_path.join(addon_metadata_filename);
+                let addon_metadata_content_tmp =
+                    std::fs::read_to_string(&addon_metadata_path_tmp).ok();
+                if let Some(content) = addon_metadata_content_tmp {
+                    parsed_meta_tmp = crate::cli::discover::metadata::parse_metadata_file(
+                        &addon.addon_type,
+                        &content,
+                    );
+                }
+            }
+        }
+
+        let base = path_utils::ensure_deva_dir()?;
+        // Use detected_addon_type (may have been found from metadata)
+        // final_addon_type is what we will report and use for metadata lookup
+        let final_addon_type = if detected_addon_type == "unknown" {
+            addon.addon_type.clone()
+        } else {
+            detected_addon_type.clone()
+        };
+
+        let target_addon_dir = match final_addon_type.as_str() {
+            "bank" => base.join("banks"),
+            "plugin" => base.join("plugins"),
+            "preset" => base.join("presets"),
+            "template" => base.join("templates"),
+            _ => {
+                // Fallback: place unknown archives into plugins by default
+                base.join("plugins")
+            }
+        };
+
+        std::fs::create_dir_all(&target_addon_dir).map_err(|e| {
+            format!(
+                "Failed to create target directory for addon {}: {}",
+                addon.name, e
+            )
+        })?;
+
+        // prefer parsed metadata publisher/name, fall back to discovered publisher/name
+        let publisher_folder = parsed_meta_tmp
+            .as_ref()
+            .and_then(|m| {
+                if !m.publisher.is_empty() {
+                    Some(m.publisher.clone())
+                } else {
+                    None
+                }
+            })
+            .unwrap_or_else(|| addon.publisher.clone());
+
+        let name_folder = parsed_meta_tmp
+            .as_ref()
+            .and_then(|m| {
+                if !m.name.is_empty() {
+                    Some(m.name.clone())
+                } else {
+                    None
+                }
+            })
+            .unwrap_or_else(|| addon.name.clone());
+
+        let target_addon_path_dir = target_addon_dir.join(&publisher_folder).join(&name_folder);
+        if target_addon_path_dir.exists() {
+            println!(
+                "Target addon directory {} already exists",
+                target_addon_path_dir.display()
+            );
+            continue;
+        }
+
+        if let Err(e) = std::fs::rename(&addon_path, &target_addon_path_dir) {
+            crate::cli::discover::fs::copy_dir_all(&addon_path, &target_addon_path_dir).map_err(
+                |err| {
+                    format!(
+                        "Failed to move addon {}: {} (rename error: {})",
+                        addon.name, err, e
+                    )
+                },
+            )?;
+            let _ = std::fs::remove_dir_all(&addon_path);
+        }
+        // Attempt to read final metadata file (use parsed_tmp as fallback)
+        let addon_metadata_filename = match final_addon_type.as_str() {
+            "bank" => "bank.toml",
+            "plugin" => "plugin.toml",
+            "preset" => "preset.toml",
+            "template" => "template.toml",
+            _ => "",
+        };
+
+        let parsed_meta = if addon_metadata_filename.is_empty() {
+            parsed_meta_tmp.unwrap_or(AddonMetadata {
+                name: "".to_string(),
+                publisher: "".to_string(),
+                version: "".to_string(),
+                description: "".to_string(),
+                access: "".to_string(),
+            })
+        } else {
+            let addon_metadata_path = target_addon_path_dir.join(addon_metadata_filename);
+            if let Ok(content) = std::fs::read_to_string(&addon_metadata_path) {
+                crate::cli::discover::metadata::parse_metadata_file(&final_addon_type, &content)
+                    .unwrap_or(parsed_meta_tmp.unwrap_or(AddonMetadata {
+                        name: "".to_string(),
+                        publisher: "".to_string(),
+                        version: "".to_string(),
+                        description: "".to_string(),
+                        access: "".to_string(),
+                    }))
+            } else {
+                parsed_meta_tmp.unwrap_or(AddonMetadata {
+                    name: "".to_string(),
+                    publisher: "".to_string(),
+                    version: "".to_string(),
+                    description: "".to_string(),
+                    access: "".to_string(),
+                })
+            }
+        };
+
+        // Record location as the final moved directory path
+        addons_enriched.push(AddonWithMetadata {
+            name: name_folder.clone(),
+            publisher: publisher_folder.clone(),
+            path: target_addon_path_dir.clone().to_string_lossy().to_string(),
+            addon_type: final_addon_type.clone(),
+            metadata: parsed_meta,
+        });
+
+        if let Err(e) = std::fs::remove_file(&addon.path) {
+            eprintln!(
+                "Failed to remove zipped file for addon {}: {}",
+                addon.name, e
+            );
+        }
+    }
+
+    // Best-effort cleanup of temporary extraction directory: remove `.deva/tmp`
+    // only if it's empty after installing the selected addons and when the
+    // user did not pass --no-clear-tmp.
+    if !no_clear_tmp {
+        if tmp_dir.exists() {
+            match std::fs::read_dir(&tmp_dir) {
+                Ok(mut rd) => {
+                    if rd.next().is_none() {
+                        let _ = std::fs::remove_dir_all(&tmp_dir);
+                    }
+                }
+                Err(_) => {
+                    // ignore errors here - best-effort
+                }
+            }
+        }
+    }
+
+    Ok(addons_enriched)
+}