Added the features selection to the CLI wizard

Added the features selection to the GUI wizard

fixed store wizard total step count

updated error handling

windows gui installation now locks the mutex

update the logic of reading config from the file and overriding it with cli args

Author: Hahihula

src-tauri/Cargo.lock

@@ -51,7 +51,7 @@ required-features = ["offline"]
 tauri-build = { version = "2.3.1", features = [], optional = true }
 
 [dependencies]
-reqwest = "0.12.4"
+reqwest = {version = "0.12.4", features = ["blocking"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_derive = "1.0"
 serde_json = "1.0"

src-tauri/Cargo.toml

@@ -71,6 +71,9 @@ wizard.idf.user_cancelled:
 wizard.idf.cloning:
   en: Cloning ESP-IDF
   cn: 正在克隆 ESP-IDF
+wizard.idf.submodule_finish:
+  en: "IDF submodule correctly downloaded to:"
+  cn: "IDF 子模块已正确下载到:"
 wizard.idf_version.selected:
   en: "Selected IDF version: %{version}"
   cn: "已选择 IDF 版本: %{version}"

src-tauri/locales/app.yml

@@ -151,14 +151,14 @@ pub async fn run_cli(cli: Cli) -> anyhow::Result<()> {
                 install_args.config.clone(),
                 install_args.clone().into_iter(),
             );
+            info!("Returned settings: {:?}", settings);
             match settings {
                 Ok(mut settings) => {
+                  info!("Settings before adjustments: {:?}", settings);
                   if install_args.install_all_prerequisites.is_none() { // if cli argument is not set
                     settings.install_all_prerequisites = Some(true); // The non-interactive install will always install all prerequisites
                   }
-                  if install_args.idf_versions.is_none() { // if no version is specified, use the latest stable (skipping pre-releases)
-                    settings.idf_versions = Some(vec![idf_im_lib::idf_versions::get_idf_names(false).await.first().unwrap().to_string()]);
-                  }
+                  info!("Settings after adjustments: {:?}", settings);
                   let time = std::time::SystemTime::now();
                   if !do_not_track {
                       track_cli_event("CLI installation started", Some(json!({
@@ -168,7 +168,7 @@ pub async fn run_cli(cli: Cli) -> anyhow::Result<()> {
                     let result = wizard::run_wizzard_run(settings).await;
                     match result {
                         Ok(r) => {
-                            info!("{}", t!("install.wizard_result"));
+                            info!("{}", t!("install.wizard_result", r = "Ok".to_string()));
                             info!("{}", t!("install.success"));
                             info!("{}", t!("install.ready"));
                             if !do_not_track {

src-tauri/src/cli/mod.rs

@@ -3,7 +3,10 @@ use std::path::PathBuf;
 use crate::cli::helpers::{
     first_defaulted_multiselect, generic_confirm, generic_input, generic_select, run_with_spinner,
 };
-use idf_im_lib::settings::Settings;
+use dialoguer::theme::ColorfulTheme;
+use dialoguer::MultiSelect;
+use idf_im_lib::idf_features::FeatureInfo;
+use idf_im_lib::{idf_features::RequirementsMetadata, settings::Settings};
 use idf_im_lib::system_dependencies;
 use log::{debug, info};
 use rust_i18n::t;
@@ -265,3 +268,191 @@ pub fn save_config_if_desired(config: &Settings) -> Result<(), String> {
     }
     Ok(())
 }
+
+/// Select features from requirements metadata with interactive or non-interactive mode
+///
+/// # Arguments
+/// * `metadata` - The requirements metadata containing available features
+/// * `non_interactive` - If true, returns all required features by default
+/// * `include_optional` - If true, allows selection of optional features (interactive mode only)
+///
+/// # Returns
+/// * `Ok(Vec<FeatureInfo>)` - Selected features
+/// * `Err(String)` - Error message
+pub fn select_features(
+    metadata: &RequirementsMetadata,
+    non_interactive: bool,
+    include_optional: bool,
+) -> Result<Vec<FeatureInfo>, String> {
+    if non_interactive {
+        // Non-interactive mode: return all required features
+        println!("Non-interactive mode: selecting all required features by default");
+        let required = metadata
+            .required_features()
+            .into_iter()
+            .cloned()
+            .collect();
+        Ok(required)
+    } else {
+        // Interactive mode: let user select features
+        select_features_interactive(metadata, include_optional)
+    }
+}
+
+/// Interactive feature selection with multi-select dialog
+fn select_features_interactive(
+    metadata: &RequirementsMetadata,
+    include_optional: bool,
+) -> Result<Vec<FeatureInfo>, String> {
+    let features_to_show: Vec<&FeatureInfo> = if include_optional {
+        metadata.features.iter().collect()
+    } else {
+        metadata.required_features()
+    };
+
+    if features_to_show.is_empty() {
+        return Err("No features available for selection".to_string());
+    }
+
+    // Create display strings for each feature
+    let items: Vec<String> = features_to_show
+        .iter()
+        .map(|f| {
+            format!(
+                "{} - {}",
+                f.name,
+                f.description.as_deref().unwrap_or("No description")
+            )
+        })
+        .collect();
+
+    // Pre-select all required features
+    let defaults: Vec<bool> = features_to_show
+        .iter()
+        .map(|f| !f.optional)
+        .collect();
+
+    // Show multi-select dialog
+    let selections = MultiSelect::with_theme(&ColorfulTheme::default())
+        .with_prompt("Select ESP-IDF features to install (Space to toggle, Enter to confirm)")
+        .items(&items)
+        .defaults(&defaults)
+        .interact()
+        .map_err(|e| format!("Selection failed: {}", e))?;
+
+    if selections.is_empty() {
+        return Err("No features selected. At least one feature must be selected.".to_string());
+    }
+
+    // Return selected features
+    let selected_features: Vec<FeatureInfo> = selections
+        .into_iter()
+        .map(|idx| features_to_show[idx].clone())
+        .collect();
+
+    Ok(selected_features)
+}
+
+/// Select features and return their names only
+pub fn select_feature_names(
+    metadata: &RequirementsMetadata,
+    non_interactive: bool,
+    include_optional: bool,
+) -> Result<Vec<String>, String> {
+    let features = select_features(metadata, non_interactive, include_optional)?;
+    Ok(features.into_iter().map(|f| f.name).collect())
+}
+
+/// Select features and return their requirement paths
+pub fn select_requirement_paths(
+    metadata: &RequirementsMetadata,
+    non_interactive: bool,
+    include_optional: bool,
+) -> Result<Vec<String>, String> {
+    let features = select_features(metadata, non_interactive, include_optional)?;
+    Ok(features.into_iter().map(|f| f.requirement_path).collect())
+}
+
+/// Advanced selection: filter by specific criteria
+pub struct FeatureSelectionOptions {
+    pub non_interactive: bool,
+    pub include_optional: bool,
+    pub show_only_optional: bool,
+    pub filter_by_name: Option<Vec<String>>,
+}
+
+impl Default for FeatureSelectionOptions {
+    fn default() -> Self {
+        Self {
+            non_interactive: false,
+            include_optional: true,
+            show_only_optional: false,
+            filter_by_name: None,
+        }
+    }
+}
+
+/// Advanced feature selection with filtering options
+pub fn select_features_advanced(
+    metadata: &RequirementsMetadata,
+    options: FeatureSelectionOptions,
+) -> Result<Vec<FeatureInfo>, String> {
+    // Apply filters
+    let mut filtered_features: Vec<&FeatureInfo> = metadata.features.iter().collect();
+
+    // Filter by optional/required
+    if options.show_only_optional {
+        filtered_features.retain(|f| f.optional);
+    } else if !options.include_optional {
+        filtered_features.retain(|f| !f.optional);
+    }
+
+    // Filter by name if specified
+    if let Some(ref names) = options.filter_by_name {
+        filtered_features.retain(|f| names.contains(&f.name));
+    }
+
+    if filtered_features.is_empty() {
+        return Err("No features match the specified criteria".to_string());
+    }
+
+    if options.non_interactive {
+        // Return all filtered features in non-interactive mode
+        println!(
+            "Non-interactive mode: selecting {} filtered feature(s)",
+            filtered_features.len()
+        );
+        Ok(filtered_features.into_iter().cloned().collect())
+    } else {
+        // Interactive selection from filtered features
+        let items: Vec<String> = filtered_features
+            .iter()
+            .map(|f| {
+                format!(
+                    "{} {} - {}",
+                    if f.optional { "[ ]" } else { "[*]" },
+                    f.name,
+                    f.description.as_deref().unwrap_or("No description")
+                )
+            })
+            .collect();
+
+        let defaults: Vec<bool> = filtered_features.iter().map(|f| !f.optional).collect();
+
+        let selections = MultiSelect::with_theme(&ColorfulTheme::default())
+            .with_prompt("Select ESP-IDF features (Space to toggle, Enter to confirm)")
+            .items(&items)
+            .defaults(&defaults)
+            .interact()
+            .map_err(|e| format!("Selection failed: {}", e))?;
+
+        if selections.is_empty() {
+            return Err("No features selected".to_string());
+        }
+
+        Ok(selections
+            .into_iter()
+            .map(|idx| filtered_features[idx].clone())
+            .collect())
+    }
+}

src-tauri/src/cli/prompts.rs

@@ -1,6 +1,8 @@
 use anyhow::anyhow;
 use anyhow::Result;
 use dialoguer::FolderSelect;
+use idf_im_lib::idf_features::get_requirements_json_url;
+use idf_im_lib::idf_features::RequirementsMetadata;
 use idf_im_lib::idf_tools::ToolsFile;
 use idf_im_lib::offline_installer::copy_idf_from_offline_archive;
 use idf_im_lib::offline_installer::install_prerequisites_offline;
@@ -328,7 +330,7 @@ async fn download_and_extract_tools(
 }
 
 pub async fn run_wizzard_run(mut config: Settings) -> Result<(), String> {
-    debug!(
+    info!(
         "{}",
         t!(
             "wizard.debug.config_entering",
@@ -413,6 +415,37 @@ pub async fn run_wizzard_run(mut config: Settings) -> Result<(), String> {
         config.idf_path = Some(paths.idf_path.clone());
         idf_im_lib::add_path_to_path(paths.idf_path.to_str().unwrap());
 
+        let req_url = get_requirements_json_url(config.repo_stub.clone().as_deref(), &idf_version.to_string(), config.idf_mirror.clone().as_deref());
+
+        let requirements_files = match RequirementsMetadata::from_url(&req_url) {
+            Ok(files) => files,
+            Err(err) => {
+                warn!("{}: {}. {}", t!("wizard.requirements.read_failure"), err, t!("wizard.features.selection_unavailable"));
+                return Err(err.to_string());
+            }
+        };
+
+        let features = select_features(
+            &requirements_files,
+            config.non_interactive.unwrap_or_default(),
+            true,
+        )?;
+        debug!(
+            "{}: {}",
+            t!("wizard.features.selected"),
+            features
+                .iter()
+                .map(|f| f.name.clone())
+                .collect::<Vec<String>>()
+                .join(", ")
+        );
+        config.idf_features = Some(
+            features
+                .iter()
+                .map(|f| f.name.clone())
+                .collect::<Vec<String>>(),
+        );
+
         if !using_existing_idf {
             // download idf
             let download_config = DownloadConfig {
@@ -442,6 +475,10 @@ pub async fn run_wizzard_run(mut config: Settings) -> Result<(), String> {
                 }
             }
         }
+        // IDF features
+
+
+
         // setup tool directories
 
         let tool_download_directory = setup_directory(

src-tauri/src/cli/wizard.rs

@@ -1,13 +1,10 @@
-use crate::gui::ui::{emit_installation_event, emit_log_message, send_message, send_tools_message, InstallationProgress, InstallationStage, MessageLevel, ProgressBar};
+use crate::gui::{app_state::{get_settings_non_blocking, update_settings}, ui::{emit_installation_event, emit_log_message, send_message, send_tools_message, InstallationProgress, InstallationStage, MessageLevel, ProgressBar}};
 use anyhow::{anyhow, Context, Result};
 
 use idf_im_lib::{
-  add_path_to_path,ensure_path,
-  idf_tools::{self, get_tools_export_paths},
-  DownloadProgress,
-  settings::Settings,
+  add_path_to_path, ensure_path, idf_features::{get_requirements_json_url, FeatureInfo, RequirementsMetadata}, idf_tools::{self, get_tools_export_paths}, settings::Settings, DownloadProgress
 };
-use log::{ error, info};
+use log::{ error, info, warn};
 use std::{
   path::{Path, PathBuf}, sync::{Arc, Mutex},
 };
@@ -419,3 +416,55 @@ pub async fn setup_tools(
 
     Ok(export_paths)
 }
+
+#[tauri::command]
+pub async fn get_features_list(
+    app_handle: AppHandle,
+) -> Result<Vec<FeatureInfo>, String> {
+  let settings = get_settings_non_blocking(&app_handle)?;
+    let first_version = match &settings.idf_versions {
+        Some(versions) if !versions.is_empty() => versions.first().unwrap(),
+        _ => {
+            let msg = t!("wizard.requirements.no_idf_version_specified").to_string();
+            warn!("{}", msg);
+            return Err(msg);
+        }
+    };
+    let req_url = get_requirements_json_url(settings.repo_stub.clone().as_deref(), &first_version.to_string(), settings.idf_mirror.clone().as_deref());
+    println!("Requirements URL: {}", req_url);
+    let requirements_files = match RequirementsMetadata::from_url_async(&req_url).await {
+        Ok(files) => files,
+        Err(err) => {
+            warn!("{}: {}. {}", t!("wizard.requirements.read_failure"), err, t!("wizard.features.selection_unavailable"));
+            return Err(err.to_string());
+        }
+    };
+
+    Ok(requirements_files.features.clone())
+}
+
+/// Sets the selected ESP-IDF features
+#[tauri::command]
+pub fn set_selected_features(
+    app_handle: AppHandle,
+    features: Vec<String>,
+) -> Result<(), String> {
+    info!("Setting selected features: {:?}", features);
+    update_settings(&app_handle, |settings| {
+        settings.idf_features = Some(features);
+    })?;
+
+    send_message(
+        &app_handle,
+        t!("gui.settings.features_updated").to_string(),
+        "info".to_string(),
+    );
+    Ok(())
+}
+
+/// Gets the currently selected features from settings
+#[tauri::command]
+pub fn get_selected_features(app_handle: AppHandle) -> Result<Vec<String>, String> {
+    let settings = get_settings_non_blocking(&app_handle)?;
+    Ok(settings.idf_features.clone().unwrap_or_default())
+}