Method handle_create_provider_key

crates/openshell-tui/src/app.rs:2126–2343

(&mut self, key: KeyEvent)

    }

    fn handle_create_provider_key(&mut self, key: KeyEvent) {
        let Some(form) = self.create_provider_form.as_mut() else {
            return;
        };

        match form.phase {
            CreateProviderPhase::SelectType => match key.code {
                KeyCode::Esc => {
                    self.create_provider_form = None;
                }
                KeyCode::Char('j') | KeyCode::Down if !form.types.is_empty() => {
                    form.type_cursor = (form.type_cursor + 1).min(form.types.len() - 1);
                }
                KeyCode::Char('k') | KeyCode::Up => {
                    form.type_cursor = form.type_cursor.saturating_sub(1);
                }
                KeyCode::Enter => {
                    let selected = form.types[form.type_cursor].clone();
                    let registry = openshell_providers::ProviderRegistry::new();
                    let env_vars = registry.credential_env_vars(&selected);
                    form.is_generic = env_vars.is_empty();

                    // Populate credential rows from all known env vars.
                    form.credentials = env_vars
                        .iter()
                        .map(|s| (s.to_string(), String::new()))
                        .collect();
                    form.cred_cursor = 0;

                    // Auto-generate a unique name.
                    form.name = unique_provider_name(&selected, &self.provider_names);

                    if form.is_generic {
                        // No known env vars — skip straight to manual entry.
                        form.phase = CreateProviderPhase::EnterKey;
                        form.key_field = ProviderKeyField::Name;
                        form.status = None;
                        form.warning = None;
                    } else {
                        form.phase = CreateProviderPhase::ChooseMethod;
                        form.method_cursor = 0;
                    }
                }
                _ => {}
            },

            CreateProviderPhase::ChooseMethod => match key.code {
                KeyCode::Esc => {
                    form.phase = CreateProviderPhase::SelectType;
                    form.status = None;
                    form.warning = None;
                }
                KeyCode::Char('j' | 'k') | KeyCode::Down | KeyCode::Up => {
                    form.method_cursor = 1 - form.method_cursor;
                }
                KeyCode::Enter => {
                    let ptype = form.types[form.type_cursor].clone();
                    if form.method_cursor == 0 {