Update dependencies and improve cache handling

Signed-off-by: Pedro Henrique Penna <ppenna@microsoft.com>

Author: ppenna

Cargo.lock

@@ -5,7 +5,7 @@ edition = "2021"
 description = "A Hyperlight VMM wrapper with out-of-the-box support for running Nanvix microkernel guests"
 
 [dependencies]
-nanvix = { git = "https://github.com/nanvix/nanvix", rev = "7752e9f2deb4a5606f9885e4c130eec4ea583de1", features = [
+nanvix = { git = "https://github.com/nanvix/nanvix", rev = "cc9c508918bd17678e9d790f10a6a7c20b7902da", features = [
     "single-process",
     "hyperlight",
 ] }

Cargo.toml

@@ -1,31 +1,37 @@
-use std::path::PathBuf;
+use nanvix::registry::Registry;
 
-/// Get the default cache directory for nanvix registry
-pub fn get_cache_directory() -> PathBuf {
-    let home_dir = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
-    std::path::Path::new(&home_dir)
-        .join(".cache")
-        .join("nanvix-registry")
-}
+/// Default machine type for hyperlight-nanvix
+const DEFAULT_MACHINE: &str = "hyperlight";
 
-/// Get the binary cache directory
-pub fn get_binary_cache_directory() -> PathBuf {
-    get_cache_directory().join("bin")
-}
+/// Default deployment type for hyperlight-nanvix
+const DEFAULT_DEPLOYMENT: &str = "single-process";
 
 /// Check if a binary exists in the cache and return its path if found
 pub async fn get_cached_binary_path(binary_name: &str) -> Option<String> {
-    let cache_path = get_binary_cache_directory().join(binary_name);
-
-    if tokio::fs::metadata(&cache_path).await.is_ok() {
-        Some(cache_path.to_string_lossy().to_string())
-    } else {
-        None
-    }
+    let registry = Registry::new(None);
+    registry
+        .get_cached_binary(DEFAULT_MACHINE, DEFAULT_DEPLOYMENT, binary_name)
+        .await
+        .ok()
 }
 
 /// Check if a binary exists in the cache (synchronous version for setup command)
 pub fn is_binary_cached(binary_name: &str) -> bool {
-    let cache_path = get_binary_cache_directory().join(binary_name);
-    cache_path.exists()
+    // Use blocking runtime to check cache synchronously
+    let registry = Registry::new(None);
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .ok();
+
+    if let Some(rt) = rt {
+        rt.block_on(async {
+            registry
+                .get_cached_binary(DEFAULT_MACHINE, DEFAULT_DEPLOYMENT, binary_name)
+                .await
+                .is_ok()
+        })
+    } else {
+        false
+    }
 }

src/cache.rs

@@ -26,6 +26,16 @@ impl WorkloadType {
         }
     }
 
+    /// Get the registry package name for this workload type.
+    /// Returns `None` for workload types that don't require a package installation.
+    pub fn package_name(&self) -> Option<&'static str> {
+        match self {
+            WorkloadType::JavaScript => Some("quickjs"),
+            WorkloadType::Python => Some("python"),
+            WorkloadType::Binary => None,
+        }
+    }
+
     /// Get the file extensions associated with this workload type
     pub fn extensions(&self) -> &'static [&'static str] {
         match self {
@@ -167,6 +177,16 @@ impl Runtime {
         let machine_type = "hyperlight";
         let deployment_type = "single-process";
 
+        // Install the required package (and its dependencies) for scripted workloads.
+        // This ensures the interpreter and all transitive dependencies are present
+        // before attempting to locate the binary.
+        if let Some(package_name) = workload_type.package_name() {
+            log::info!("Installing package '{}' and dependencies...", package_name);
+            self.registry
+                .install(machine_type, deployment_type, package_name, true)
+                .await?;
+        }
+
         // Get interpreter binary (only needed for scripted workloads)
         let binary_path = if matches!(workload_type, WorkloadType::Binary) {
             // For binary workloads, we don't need an interpreter