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

package/rust/cli/discover/install.rs

@@ -3,6 +3,7 @@ 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();
 
@@ -16,14 +17,72 @@ pub async fn install_selected_addons(
         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()?;
-        let target_addon_dir = match addon.addon_type.as_str() {
+        // 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"),
             _ => {
-                return Err(format!("Unknown addon type for addon {}", addon.name));
+                // Fallback: place unknown archives into plugins by default
+                base.join("plugins")
             }
         };
 
@@ -34,7 +93,30 @@ pub async fn install_selected_addons(
             )
         })?;
 
-        let target_addon_path_dir = target_addon_dir.join(&addon.name);
+        // 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",
@@ -54,37 +136,51 @@ pub async fn install_selected_addons(
             )?;
             let _ = std::fs::remove_dir_all(&addon_path);
         }
-
-        let addon_metadata_filename = match addon.addon_type.as_str() {
+        // 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",
-            _ => {
-                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(),
-        });
+        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: addon.name.clone(),
-            path: addon.path.clone().to_string_lossy().to_string(),
-            addon_type: addon.addon_type.clone(),
+            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,
         });
 
@@ -96,8 +192,23 @@ pub async fn install_selected_addons(
         }
     }
 
-    // Best-effort cleanup of temporary extraction directory
-    let _ = std::fs::remove_dir_all(&tmp_dir);
+    // 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)
 }

package/rust/cli/discover/metadata.rs

@@ -27,8 +27,8 @@ pub fn parse_metadata_file(addon_type: &str, metadata_content: &str) -> Option<A
         .and_then(|v| v.as_str())
         .unwrap_or("")
         .to_string();
-    let author = table
-        .get("author")
+    let publisher = table
+        .get("publisher")
         .and_then(|v| v.as_str())
         .unwrap_or("unknown")
         .to_string();
@@ -40,7 +40,7 @@ pub fn parse_metadata_file(addon_type: &str, metadata_content: &str) -> Option<A
 
     Some(AddonMetadata {
         name,
-        author,
+        publisher,
         version,
         description,
         access,

package/rust/cli/login/commands.rs

@@ -1,124 +1,124 @@
-use crate::config::settings::set_user_config_value;
-use crate::web::sso::get_sso_url;
-use std::str::FromStr;
-use tiny_http::Header;
-use tiny_http::{Response, Server};
-use webbrowser;
-
-/// Handle the login command
-/// This function initiates the login process by opening the browser and waiting for the callback.
-#[cfg(feature = "cli")]
-pub async fn handle_login_command() -> Result<(), String> {
-    use devalang_utils::logger::LogLevel;
-    use devalang_utils::logger::Logger;
-    use devalang_utils::spinner::start_spinner;
-
-    let logger = Logger::new();
-
-    let mut listener_port = 7878;
-
-    let test_port_already_in_use = format!("127.0.0.1:{}", listener_port);
-    while std::net::TcpListener::bind(&test_port_already_in_use).is_err() {
-        listener_port += 1;
-    }
-
-    let redirect_uri = format!("http://127.0.0.1:{}/callback", listener_port);
-    let login_url = format!(
-        "{}/?response_type=code&referer=cli&redirect_uri={}",
-        get_sso_url(),
-        redirect_uri
-    );
-
-    if webbrowser::open(&login_url).is_ok() {
-        logger.log_message(LogLevel::Info, "Opening browser for login...");
-        logger.log_message(
-            LogLevel::Info,
-            &format!(
-                "If the browser does not open, please visit the following URL: {}",
-                login_url
-            ),
-        );
-    } else {
-        logger.log_message(
-            LogLevel::Info,
-            "Please open the following URL in your browser to login:",
-        );
-        logger.log_message(LogLevel::Info, &login_url);
-    }
-
-    let server = Server::http(format!("127.0.0.1:{}", listener_port)).unwrap();
-
-    let spinner = start_spinner("Waiting for authentication...");
-
-    for request in server.incoming_requests() {
-        let query = request.url().to_string();
-        if request.url().starts_with("/callback") {
-            if query.contains("session=") || query.contains("error=") {
-                let token = query.split("session=").nth(1).unwrap_or("").to_string();
-
-                if !token.is_empty() {
-                    let response_html = r#"
-                        <html>
-                            <body>
-                                <h1>Authentication Successful</h1>
-                                <h2>You can now close this window.</h2>
-                            </body>
-                        </html>
-                    "#;
-
-                    let response = Response::from_string(response_html)
-                        .with_status_code(200)
-                        .with_header(Header::from_str("Content-Type: text/html").unwrap());
-
-                    request.respond(response).unwrap();
-
-                    save_token(&token);
-
-                    spinner.finish_and_clear();
-
-                    logger.log_message(
-                        LogLevel::Success,
-                        "Authentication successful. Token saved to ~/.devalang/config.json",
-                    );
-
-                    break;
-                } else {
-                    spinner.finish_and_clear();
-                    logger.log_message(LogLevel::Error, "Invalid session token.");
-                    request
-                        .respond(Response::from_string("Invalid session token."))
-                        .unwrap();
-
-                    break;
-                }
-            } else {
-                println!("Invalid callback: {}", request.url());
-
-                spinner.finish_and_clear();
-                logger.log_message(LogLevel::Error, "Invalid callback.");
-                request
-                    .respond(Response::from_string("Invalid callback."))
-                    .unwrap();
-
-                break;
-            }
-        } else if request.url().starts_with("/favicon.ico") {
-            // Ignore favicon requests
-        } else {
-            spinner.finish_and_clear();
-            logger.log_message(LogLevel::Error, "Invalid request.");
-            request
-                .respond(Response::from_string("Invalid request."))
-                .unwrap();
-
-            break;
-        }
-    }
-
-    Ok(())
-}
-
-/// Save the session token to a file in the user's home directory
-fn save_token(token: &str) {
-    set_user_config_value("session", serde_json::Value::String(token.to_string()));
-}
+use crate::config::settings::set_user_config_value;
+use crate::web::sso::get_sso_url;
+use std::str::FromStr;
+use tiny_http::Header;
+use tiny_http::{Response, Server};
+use webbrowser;
+
+/// Handle the login command
+/// This function initiates the login process by opening the browser and waiting for the callback.
+#[cfg(feature = "cli")]
+pub async fn handle_login_command() -> Result<(), String> {
+    use devalang_utils::logger::LogLevel;
+    use devalang_utils::logger::Logger;
+    use devalang_utils::spinner::start_spinner;
+
+    let logger = Logger::new();
+
+    let mut listener_port = 7878;
+
+    let test_port_already_in_use = format!("127.0.0.1:{}", listener_port);
+    while std::net::TcpListener::bind(&test_port_already_in_use).is_err() {
+        listener_port += 1;
+    }
+
+    let redirect_uri = format!("http://127.0.0.1:{}/callback", listener_port);
+    let login_url = format!(
+        "{}/?response_type=code&referer=cli&redirect_uri={}",
+        get_sso_url(),
+        redirect_uri
+    );
+
+    if webbrowser::open(&login_url).is_ok() {
+        logger.log_message(LogLevel::Info, "Opening browser for login...");
+        logger.log_message(
+            LogLevel::Info,
+            &format!(
+                "If the browser does not open, please visit the following URL: {}",
+                login_url
+            ),
+        );
+    } else {
+        logger.log_message(
+            LogLevel::Info,
+            "Please open the following URL in your browser to login:",
+        );
+        logger.log_message(LogLevel::Info, &login_url);
+    }
+
+    let server = Server::http(format!("127.0.0.1:{}", listener_port)).unwrap();
+
+    let spinner = start_spinner("Waiting for authentication...");
+
+    for request in server.incoming_requests() {
+        let query = request.url().to_string();
+        if request.url().starts_with("/callback") {
+            if query.contains("session=") || query.contains("error=") {
+                let token = query.split("session=").nth(1).unwrap_or("").to_string();
+
+                if !token.is_empty() {
+                    let response_html = r#"
+                        <html>
+                            <body>
+                                <h1>Authentication Successful</h1>
+                                <h2>You can now close this window.</h2>
+                            </body>
+                        </html>
+                    "#;
+
+                    let response = Response::from_string(response_html)
+                        .with_status_code(200)
+                        .with_header(Header::from_str("Content-Type: text/html").unwrap());
+
+                    request.respond(response).unwrap();
+
+                    save_token(&token);
+
+                    spinner.finish_and_clear();
+
+                    logger.log_message(
+                        LogLevel::Success,
+                        "Authentication successful. Token saved to ~/.devalang/config.json",
+                    );
+
+                    break;
+                } else {
+                    spinner.finish_and_clear();
+                    logger.log_message(LogLevel::Error, "Invalid session token.");
+                    request
+                        .respond(Response::from_string("Invalid session token."))
+                        .unwrap();
+
+                    break;
+                }
+            } else {
+                println!("Invalid callback: {}", request.url());
+
+                spinner.finish_and_clear();
+                logger.log_message(LogLevel::Error, "Invalid callback.");
+                request
+                    .respond(Response::from_string("Invalid callback."))
+                    .unwrap();
+
+                break;
+            }
+        } else if request.url().starts_with("/favicon.ico") {
+            // Ignore favicon requests
+        } else {
+            spinner.finish_and_clear();
+            logger.log_message(LogLevel::Error, "Invalid request.");
+            request
+                .respond(Response::from_string("Invalid request."))
+                .unwrap();
+
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+/// Save the session token to a file in the user's home directory
+fn save_token(token: &str) {
+    set_user_config_value("session", serde_json::Value::String(token.to_string()));
+}

package/rust/cli/me/commands.rs

@@ -0,0 +1,52 @@
+pub async fn handle_me_command() -> Result<(), String> {
+    let auth_url = crate::web::auth::get_auth_url();
+
+    let url = format!("{}/v1/auth/me", auth_url);
+
+    let client = reqwest::Client::new();
+    let mut req = client.get(url);
+
+    if let Some(user) = crate::config::settings::get_user_config() {
+        if !user.session.is_empty() {
+            req = req.bearer_auth(user.session);
+        }
+    } else {
+        return Err("No user session found. Please log in.".to_string());
+    }
+
+    let response = req.send().await.map_err(|e| e.to_string())?;
+
+    if !response.status().is_success() {
+        return Err(format!("Failed to get user info: HTTP {}", response.status()).into());
+    }
+
+    let status = response.status();
+    let body_text = response
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read response body: {}", e))?;
+
+    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
+            ));
+        }
+    };
+
+    let payload = json.get("payload");
+
+    let email = payload
+        .unwrap_or(&serde_json::Value::Null)
+        .get("userData")
+        .unwrap_or(&serde_json::Value::Null)
+        .get("email")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown");
+
+    println!("Logged in as: {}", email);
+
+    Ok(())
+}

package/rust/cli/me/mod.rs

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

package/rust/cli/mod.rs

@@ -1,10 +1,10 @@
-pub mod bank;
+pub mod addon;
 pub mod build;
 pub mod check;
 pub mod discover;
 pub mod init;
-pub mod install;
 pub mod login;
+pub mod me;
 pub mod parser;
 pub mod play;
 pub mod telemetry;