IDF installed using eim or eclipse can be discovered

Author: Hahihula

src-tauri/src/cli/mod.rs

@@ -10,6 +10,7 @@ use helpers::generic_select;
 use idf_im_lib::get_log_directory;
 use idf_im_lib::idf_config::IdfConfig;
 use idf_im_lib::settings::Settings;
+use idf_im_lib::utils::try_import_existing_idf;
 use idf_im_lib::version_manager::remove_single_idf_version;
 use idf_im_lib::version_manager::select_idf_version;
 use log::debug;
@@ -326,6 +327,16 @@ pub async fn run_cli(cli: Cli) {
               }
 
             }
+            for p in paths_to_add {
+              match try_import_existing_idf(&p) {
+                Ok(_) => {
+                  info!("Added to config: {}", p);
+                }
+                Err(err) => {
+                  error!("Failed to add: {} - reason :{}",p, err);
+                }
+              }
+            }
         }
         Commands::Import { path } => match path {
             Some(config_file) => {

src-tauri/src/lib/utils.rs

@@ -1,21 +1,15 @@
 use crate::{
-    command_executor::execute_command,
-    idf_config::{IdfConfig, IdfInstallation},
-    idf_tools::read_and_parse_tools_file,
-    single_version_post_install,
-    version_manager::get_default_config_path,
+    command_executor::execute_command, idf_config::{IdfConfig, IdfInstallation}, idf_tools::{self, read_and_parse_tools_file}, replace_unescaped_spaces_win, settings::Settings, single_version_post_install, version_manager::get_default_config_path
 };
 use anyhow::{anyhow, Result};
 use log::{debug, warn};
 use rust_search::SearchBuilder;
 use serde::{Deserialize, Serialize};
+use uuid::Uuid;
 #[cfg(not(windows))]
 use std::os::unix::fs::MetadataExt;
 use std::{
-    collections::{HashMap, HashSet},
-    fs::{self},
-    io,
-    path::{Path, PathBuf},
+    collections::{HashMap, HashSet}, fmt::format, fs::{self}, io, path::{Path, PathBuf}
 };
 /// This function retrieves the path to the git executable.
 ///
@@ -369,6 +363,99 @@ pub fn parse_tool_set_config(config_path: &str) -> Result<()> {
     Ok(())
 }
 
+pub fn try_import_existing_idf(idf_path:&str) -> Result<()> {
+  let path = Path::new(idf_path);
+  let default_settings = Settings::default();
+
+  // test if was installed by eim
+  if let Some(parent_dir) = path.parent() {
+    let parent_filename = parent_dir.file_name().unwrap().to_str().unwrap();
+    if let Some(grandparent_dir) = parent_dir.parent() {
+      let target_dir = grandparent_dir;
+      if let Ok(entries) = fs::read_dir(target_dir) {
+        for entry in entries {
+          if let Ok(entry) = entry {
+            if let Some(file_name) = entry.file_name().to_str() {
+              if file_name.starts_with(&format!("activate_idf_{}",parent_filename)) && entry.file_type().map(|ft| ft.is_file()).unwrap_or(false) {
+                // was installed by EIM
+
+                let installation = IdfInstallation {
+                  id: format!("esp-idf-{}", Uuid::new_v4().to_string().replace("-", "")),
+                  activation_script: entry.path().to_str().unwrap().to_string(),
+                  path: idf_path.to_string(),
+                  name: parent_filename.to_string(),
+                  python: "python".to_string(),
+                  idf_tools_path: default_settings.idf_tools_path.unwrap(),
+                };
+                let config_path = get_default_config_path();
+                let mut current_config = match IdfConfig::from_file(&config_path) {
+                    Ok(config) => config,
+                    Err(e) => {
+                      IdfConfig::default()
+                    }
+                };
+                current_config.idf_installed.push(installation);
+                match current_config.to_file(config_path, true, false) {
+                    Ok(_) => {
+                        debug!("Updated config file with new tool set");
+                        return Ok(());
+                    }
+                    Err(e) => {
+                        return Err(anyhow!("Failed to update config file: {}", e));
+                    }
+                }
+              }
+            }
+          }
+        }
+     }
+    }
+  }
+  // was not installed by eim
+  let path_to_create_activation_script = match path.parent() {
+    Some(parent) => parent,
+    None => path,
+  };
+  let idf_version = path_to_create_activation_script.file_name().unwrap().to_str().unwrap();
+  let tools_file = match idf_tools::read_and_parse_tools_file(&Path::new(idf_path).join("tools").join("tools.json").to_str().unwrap()){
+    Ok(tools_file) => tools_file,
+    Err(e) => {
+      return Err(anyhow!("Failed to read tools.json file: {}", e));
+    }
+  };
+  let export_paths = idf_tools::get_tools_export_paths(
+    tools_file,
+    ["all".to_string()].to_vec(),
+    &default_settings.tool_install_folder_name.unwrap(),
+  )
+  .into_iter()
+  .map(|p| {
+      if std::env::consts::OS == "windows" {
+          replace_unescaped_spaces_win(&p)
+      } else {
+          p
+      }
+  })
+  .collect();
+  match import_single_version(
+    path_to_create_activation_script.to_str().unwrap(),
+    idf_path,
+    idf_version,
+    &default_settings.idf_tools_path.unwrap(),
+    export_paths,
+    None,
+  ) {
+    Ok(_) => {
+      debug!("Successfully imported tool set");
+    }
+    Err(e) => {
+      warn!("Failed to import tool set: {}", e);
+    }
+  }
+  //  TODO: add more approaches for different legacy installations
+  Ok(())
+}
+
 pub fn import_single_version(path_to_create_activation_script: &str,idf_location: &str, idf_version: &str, idf_tools_path: &str, export_paths: Vec<String>, python: Option<String>) -> Result<()> {
   single_version_post_install(
     path_to_create_activation_script,