Added fix command for reinstalling the IDF

Author: Hahihula

.github/workflows/build.yaml

@@ -191,7 +191,7 @@ jobs:
           perl -MText::Template -e "print 'Text::Template loaded successfully\n'"
           perl -MParams::Check -e "print 'Params::Check loaded successfully\n'"
           perl -MIPC::Cmd -e "print 'IPC::Cmd loaded successfully\n'"
-          $perl_lib_path = "C:\hostedtoolcache\windows\perl\5.38.4-thr\x64\site\lib"
+          $perl_lib_path = "C:\hostedtoolcache\windows\perl\5.38.5-thr\x64\site\lib"
           echo "PERL5LIB=$perl_lib_path" >> $env:GITHUB_ENV
 
       - name: Cache cargo
@@ -211,7 +211,7 @@ jobs:
           OPENSSL_LIB_DIR: 'C:\vcpkg\installed\x64-windows-static-md\lib'
           OPENSSL_INCLUDE_DIR: 'C:\vcpkg\installed\x64-windows-static-md\include'
           OPENSSL_STATIC: "1"
-          PERL: 'C:\\hostedtoolcache\\windows\\perl\\5.38.4-thr\\x64\\bin\\perl.exe'
+          PERL: 'C:\\hostedtoolcache\\windows\\perl\\5.38.5-thr\\x64\\bin\\perl.exe'
         run: |
           cd src-tauri
           cargo build --release --no-default-features --features cli ${{ matrix.target && format('--target {0}', matrix.target) || '' }}

docs/src/cli_commands.md

@@ -144,6 +144,16 @@ eim discover
 
 This command is planned to discover ESP-IDF installations on your system but is not yet implemented.
 
+### Fix Command
+
+Fix the ESP-IDF installation by reinstalling the tools and dependencies
+
+```bash
+eim fix [PATH]
+```
+
+If no `PATH` is provided, the user will be presented with selection of all known IDF installation to select from.
+
 ## Examples
 
 ```bash

src-tauri/src/cli/cli_args.rs

@@ -96,6 +96,12 @@ pub enum Commands {
     /// Run the ESP-IDF Installer GUI with arguments passed through command line
     #[cfg(feature = "gui")]
     Gui(InstallArgs),
+
+    /// Fix the ESP-IDF installation by reinstalling the tools and dependencies
+    Fix {
+        #[arg(help = "Fix IDF on a specific path")]
+        path: Option<String>,
+    },
 }
 
 #[derive(Parser, Debug, Clone, Default)]

src-tauri/src/cli/mod.rs

@@ -10,6 +10,7 @@ use helpers::generic_input;
 use helpers::generic_select;
 use idf_im_lib::get_log_directory;
 use idf_im_lib::settings::Settings;
+use idf_im_lib::utils::is_valid_idf_directory;
 use idf_im_lib::version_manager::remove_single_idf_version;
 use idf_im_lib::version_manager::select_idf_version;
 use log::debug;
@@ -353,7 +354,7 @@ pub async fn run_cli(cli: Cli) -> anyhow::Result<()> {
                             println!("Available versions:");
                             let options = versions.iter().map(|v| v.name.clone()).collect();
                             match generic_select("Which version do you want to remove?", &options) {
-                                Ok(selected) => match remove_single_idf_version(&selected) {
+                                Ok(selected) => match remove_single_idf_version(&selected, false) {
                                     Ok(_) => {
                                         info!("Removed version: {}", selected);
                                         Ok(())
@@ -367,7 +368,7 @@ pub async fn run_cli(cli: Cli) -> anyhow::Result<()> {
                     Err(err) => Err(anyhow::anyhow!(err)),
                 }
             } else {
-                match remove_single_idf_version(&version.clone().unwrap()) {
+                match remove_single_idf_version(&version.clone().unwrap(), false) {
                     Ok(_) => {
                         println!("Removed version: {}", version.clone().unwrap());
                         Ok(())
@@ -388,7 +389,7 @@ pub async fn run_cli(cli: Cli) -> anyhow::Result<()> {
                         let mut failed = false;
                         for version in versions {
                             info!("Removing version: {}", version.name);
-                            match remove_single_idf_version(&version.name) {
+                            match remove_single_idf_version(&version.name, false) {
                                 Ok(_) => {
                                     info!("Removed version: {}", version.name);
                                 }
@@ -432,6 +433,89 @@ pub async fn run_cli(cli: Cli) -> anyhow::Result<()> {
                 Err(err) => Err(anyhow::anyhow!(err)),
             }
         }
+        Commands::Fix { path } => {
+          let path_to_fix = if path.is_some() {
+              // If a path is provided, fix the IDF installation at that path
+              let path = path.unwrap();
+               if is_valid_idf_directory(&path) {
+                PathBuf::from(path)
+               } else {
+                error!("Invalid IDF directory: {}", path);
+                return Err(anyhow::anyhow!("Invalid IDF directory: {}", path));
+               }
+            } else {
+              match idf_im_lib::version_manager::list_installed_versions() {
+                Ok(versions) => {
+                  if versions.is_empty() {
+                      warn!("No versions installed");
+                      return Ok(());
+                  } else {
+                    let options = versions.iter().map(|v| v.path.clone()).collect();
+                    let version_path = match helpers::generic_select(
+                        "Which version do you want to fix?",
+                        &options,
+                    ) {
+                        Ok(selected) => selected,
+                        Err(err) => {
+                            error!("Error: {}", err);
+                            return Err(anyhow::anyhow!(err));
+                        }
+                    };
+                    PathBuf::from(version_path)
+                  }
+                }
+                Err(err) => {
+                  debug!("Error: {}", err);
+                  return Err(anyhow::anyhow!("No versions found. Use eim install to install a new ESP-IDF version."));
+                }
+            }
+          };
+          info!("Fixing IDF installation at path: {}", path_to_fix.display());
+          // The fix logic is just instalation with use of existing repository
+          let mut version_name = None;
+          match idf_im_lib::version_manager::list_installed_versions() {
+            Ok(versions) => {
+              for v in versions {
+                if v.path == path_to_fix.to_str().unwrap() {
+                  info!("Found existing IDF version: {}", v.name);
+                  // Remove the existing activation script and eim_idf.json entry
+                  match remove_single_idf_version(&v.name, true) {
+                    Ok(_) => {
+                      info!("Removed existing IDF version from eim_idf.json: {}", v.name);
+                      version_name = Some(v.name.clone());
+                    }
+                    Err(err) => {
+                      error!("Failed to remove existing IDF version {}: {}", v.name, err);
+                    }
+                  }
+                }
+              }
+            }
+            Err(_) => {
+              info!("Failed to list installed versions. Using default naming.");
+            }
+          }
+
+          let mut settings = Settings::default();
+          settings.path = Some(path_to_fix.clone());
+          settings.non_interactive = Some(true);
+          settings.version_name = version_name;
+          settings.install_all_prerequisites = Some(true);
+          settings.config_file_save_path = None;
+          let result = wizard::run_wizzard_run(settings).await;
+          match result {
+            Ok(r) => {
+              info!("Fix result: {:?}", r);
+              info!("Successfully fixed IDF installation at {}", path_to_fix.display());
+            }
+            Err(err) => {
+              error!("Failed to fix IDF installation: {}", err);
+              return Err(anyhow::anyhow!(err));
+            }
+          }
+          info!("Now you can start using IDF tools");
+          Ok(())
+        }
         #[cfg(feature = "gui")]
         Commands::Gui(_install_args) => {
             #[cfg(not(feature = "gui"))]

src-tauri/src/lib/version_manager.rs

@@ -173,7 +173,7 @@ pub fn rename_idf_version(identifier: &str, new_name: String) -> Result<String>
 ///
 /// * `Result<String, anyhow::Error>` - On success, returns a `Result` containing a string message indicating
 ///   that the version has been removed. On error, returns an `anyhow::Error` with a description of the error.
-pub fn remove_single_idf_version(identifier: &str) -> Result<String> {
+pub fn remove_single_idf_version(identifier: &str, keep_idf_folder: bool) -> Result<String> {
     //TODO: remove also from path
     let config_path = get_default_config_path();
     let mut ide_config = IdfConfig::from_file(&config_path)?;
@@ -183,11 +183,18 @@ pub fn remove_single_idf_version(identifier: &str) -> Result<String> {
         .find(|install| install.id == identifier || install.name == identifier)
     {
         let installation_folder_path = PathBuf::from(installation.path.clone());
-        let installation_folder = installation_folder_path.parent().unwrap();
-        match remove_directory_all(installation_folder) {
-            Ok(_) => {}
-            Err(e) => {
-                return Err(anyhow!("Failed to remove installation folder: {}", e));
+        let installation_folder = installation_folder_path.parent().ok_or_else(|| {
+            anyhow!(
+                "Installation path '{}' has no parent directory",
+                installation_folder_path.display()
+            )
+        })?;
+        if !keep_idf_folder {
+            match remove_directory_all(installation_folder) {
+                Ok(_) => {}
+                Err(e) => {
+                    return Err(anyhow!("Failed to remove installation folder: {}", e));
+                }
             }
         }
         match remove_directory_all(installation.clone().activation_script) {