update

Author: namchuai

engine/cli/commands/engine_install_cmd.cc

@@ -84,12 +84,25 @@ bool EngineInstallCmd::Exec(const std::string& engine,
     std::vector<std::string> variant_selections;
     for (const auto& variant : variant_result.value()) {
       auto v_name = variant["name"].asString();
-      if (string_utils::StringContainsIgnoreCase(v_name, hw_inf_.sys_inf->os)) {
+      if (string_utils::StringContainsIgnoreCase(v_name, hw_inf_.sys_inf->os) &&
+          string_utils::StringContainsIgnoreCase(v_name,
+                                                 hw_inf_.sys_inf->arch)) {
         variant_selections.push_back(variant["name"].asString());
       }
     }
-    auto selected_variant =
-        cli_selection_utils::PrintSelection(variant_selections);
+    if (variant_selections.empty()) {
+      CTL_ERR("No suitable variant found for " << hw_inf_.sys_inf->os << " "
+                                               << hw_inf_.sys_inf->arch);
+      return false;
+    }
+
+    std::optional<std::string> selected_variant = std::nullopt;
+    if (variant_selections.size() == 1) {
+      selected_variant = variant_selections[0];
+    } else {
+      selected_variant =
+          cli_selection_utils::PrintSelection(variant_selections);
+    }
     if (selected_variant == std::nullopt) {
       CTL_ERR("Invalid variant selection");
       return false;

engine/cli/main.cc

@@ -171,7 +171,7 @@ int main(int argc, char* argv[]) {
       CLI_LOG(
           "New llama.cpp version available: " << config.latestLlamacppRelease);
       CLI_LOG("To update, run: " << commands::GetCortexBinary()
-                                 << " engines update llama-cpp");
+                                 << " engines update llama-cpp\n");
     }
   });
   t1.detach();

engine/services/engine_service.cc

@@ -181,6 +181,16 @@ cpp::result<bool, std::string> EngineService::UninstallEngineVariant(
     const std::string& engine, const std::optional<std::string> version,
     const std::optional<std::string> variant) {
   auto ne = NormalizeEngine(engine);
+  if (IsEngineLoaded(ne)) {
+    CTL_INF("Engine " << ne << " is already loaded, unloading it");
+    auto unload_res = UnloadEngine(ne);
+    if (unload_res.has_error()) {
+      CTL_INF("Failed to unload engine: " << unload_res.error());
+      return cpp::fail(unload_res.error());
+    } else {
+      CTL_INF("Engine " << ne << " unloaded successfully");
+    }
+  }
 
   std::optional<std::filesystem::path> path_to_remove = std::nullopt;
   if (version == std::nullopt && variant == std::nullopt) {
@@ -264,6 +274,16 @@ cpp::result<void, std::string> EngineService::DownloadEngineV2(
   if (selected_variant == std::nullopt) {
     return cpp::fail("Failed to find a suitable variant for " + engine);
   }
+  if (IsEngineLoaded(engine)) {
+    CTL_INF("Engine " << engine << " is already loaded, unloading it");
+    auto unload_res = UnloadEngine(engine);
+    if (unload_res.has_error()) {
+      CTL_INF("Failed to unload engine: " << unload_res.error());
+      return cpp::fail(unload_res.error());
+    } else {
+      CTL_INF("Engine " << engine << " unloaded successfully");
+    }
+  }
   auto normalize_version = "v" + selected_variant->version;
 
   auto variant_folder_name = engine_matcher_utils::GetVariantFromNameAndVersion(
@@ -276,7 +296,7 @@ cpp::result<void, std::string> EngineService::DownloadEngineV2(
   auto variant_path = variant_folder_path / selected_variant->name;
   std::filesystem::create_directories(variant_folder_path);
   CLI_LOG("variant_folder_path: " + variant_folder_path.string());
-  auto on_finished = [this, engine, selected_variant,
+  auto on_finished = [this, engine, selected_variant, variant_folder_path,
                       normalize_version](const DownloadTask& finishedTask) {
     // try to unzip the downloaded file
     CLI_LOG("Engine zip path: " << finishedTask.items[0].localPath.string());
@@ -299,6 +319,22 @@ cpp::result<void, std::string> EngineService::DownloadEngineV2(
       CTL_INF("Set default engine variant: " << res.value().variant);
     }
 
+    // remove other engines
+    auto engine_directories = file_manager_utils::GetEnginesContainerPath() /
+                              engine / selected_variant->name;
+
+    for (const auto& entry : std::filesystem::directory_iterator(
+             variant_folder_path.parent_path())) {
+      if (entry.is_directory() &&
+          entry.path().filename() != normalize_version) {
+        try {
+          std::filesystem::remove_all(entry.path());
+        } catch (const std::exception& e) {
+          CTL_WRN("Could not delete directory: " << e.what());
+        }
+      }
+    }
+
     // remove the downloaded file
     try {
       std::filesystem::remove(finishedTask.items[0].localPath);
@@ -364,6 +400,16 @@ cpp::result<bool, std::string> EngineService::DownloadEngine(
         CTL_INF("Creating " << engine_folder_path.string());
         std::filesystem::create_directories(engine_folder_path);
       }
+      if (IsEngineLoaded(engine)) {
+        CTL_INF("Engine " << engine << " is already loaded, unloading it");
+        auto unload_res = UnloadEngine(engine);
+        if (unload_res.has_error()) {
+          CTL_INF("Failed to unload engine: " << unload_res.error());
+          return cpp::fail(unload_res.error());
+        } else {
+          CTL_INF("Engine " << engine << " unloaded successfully");
+        }
+      }
       CTL_INF("Engine folder path: " << engine_folder_path.string() << "\n");
       auto local_path = engine_folder_path / asset.name;
       auto downloadTask{
@@ -918,6 +964,17 @@ cpp::result<EngineUpdateResult, std::string> EngineService::UpdateEngine(
   CTL_INF("Default variant: " << default_variant->variant
                               << ", version: " + default_variant->version);
 
+  if (IsEngineLoaded(ne)) {
+    CTL_INF("Engine " << ne << " is already loaded, unloading it");
+    auto unload_res = UnloadEngine(ne);
+    if (unload_res.has_error()) {
+      CTL_INF("Failed to unload engine: " << unload_res.error());
+      return cpp::fail(unload_res.error());
+    } else {
+      CTL_INF("Engine " << ne << " unloaded successfully");
+    }
+  }
+
   auto latest_version = GetLatestEngineVersion(ne);
   if (latest_version.has_error()) {
     // if can't get latest version, stop