fix: numpad Enter submit and AUR after system update

- fix: treat KeyCode::Char('\n'|\r') as submit in password prompt and modals.
- fix: treat numpad Enter as submit in search, recent panel, install flow.
- fix: queue AUR update after pacman succeeds in system update flow.
- test: add numpad Enter tests for modals (alert, confirm, help, news, etc.).
- test: add handle_tick test for AUR queue after system update success.
- chore: add PR description for fix/numpad-enter (dev/PR/).

Author: Firstp1ck

dev/PR/PR_fix-numpad-enter.md

@@ -0,0 +1,101 @@
+<!-- Thank you for contributing to Pacsea!
+
+**Important references:**
+- [CONTRIBUTING.md](../CONTRIBUTING.md) — Full contribution guidelines and PR process
+- [PR_DESCRIPTION.md](../Documents/PR_DESCRIPTION.md) — Detailed PR description template
+- [Development Wiki](https://github.com/Firstp1ck/Pacsea/wiki/Development) — Development tools and debugging
+
+Please ensure you've reviewed these before submitting your PR.
+-->
+
+## Summary
+
+- **Problem:** Numpad Enter did not submit the password prompt; it could insert a character or do nothing. On some terminals (e.g. Wayland/Alacritty), numpad Enter is reported as `KeyCode::Char('\r')` or `KeyCode::Char('\n')` instead of `KeyCode::Enter`, and only main Enter was handled as submit.
+- **Fix:** Treat `KeyCode::Char('\n')` and `KeyCode::Char('\r')` as submit alongside `KeyCode::Enter` in the password prompt and extend the same behaviour for consistency across search, modals (Alert, Help, Confirm, optional deps, import, system update, etc.), recent panel, and install flow.
+- **Implementation:** In `src/events/modals/password.rs`, submit arm is `KeyCode::Enter | KeyCode::Char('\n' | '\r')`. Same “Enter = submit” semantics applied in search (normal/insert), modal handlers, recent, and install. PostSummary excluded-keys includes `Char('\n')` and `Char('\r')` for restore logic.
+- **Tests:** Unit tests for password handler (numpad Enter as `\r`/`\n`, main Enter, regression, edge cases) and modal numpad Enter tests (Alert, Help, Confirm, PostSummary, GnomeTerminalPrompt, ImportHelp, VirusTotalSetup, News).
+
+- **Problem (Update system):** When using all selections in the "Update system" modal (mirrors + pacman + AUR + cache), AUR packages were not updated. The AUR command was stored separately and only run when pacman failed (ConfirmAurUpdate); it was never run when pacman succeeded.
+- **Fix (Update system):** Store password and header_chips when submitting the Update password so they are available after the first batch. In the tick handler, when `PreflightExec` shows success with empty items (system update) and `pending_aur_update_command` is set, queue the AUR command; AUR then runs automatically after pacman succeeds.
+- **Implementation (Update system):** Handlers: set `pending_executor_password` and `pending_exec_header_chips` on Update submit. Tick handler: new `maybe_queue_aur_after_system_update_success()`; call it from `handle_tick`.
+- **Tests (Update system):** `handle_tick_queues_aur_after_system_update_success` verifies AUR is queued after system update success when pacman + AUR were selected.
+
+## Type of change
+
+- [ ] feat (new feature)
+- [x] fix (bug fix)
+- [ ] docs (documentation only)
+- [ ] refactor (no functional change)
+- [ ] perf (performance)
+- [x] test (add/update tests)
+- [ ] chore (build/infra/CI)
+- [ ] ui (visual/interaction changes)
+- [ ] breaking change (incompatible behavior)
+
+## Related issues
+
+Closes #119
+
+## How to test
+
+1. Run quality checks:
+```bash
+cargo fmt --all
+cargo clippy --all-targets --all-features -- -D warnings
+cargo check
+cargo test -- --test-threads=1
+```
+
+2. Manual: trigger a password prompt (e.g. install a package that prompts for sudo password), type password, press **numpad Enter** — password should submit and flow continue (same as main Enter).
+
+3. Manual: in search, modals (confirm, alert, help, etc.), recent panel, and install flow, verify numpad Enter acts as submit/confirm where main Enter does.
+
+## Screenshots / recordings (if UI changes)
+
+N/A — key handling only; no visual change.
+
+## Checklist
+
+**Code Quality:**
+- [ ] Code compiles locally (`cargo check`)
+- [ ] `cargo fmt --all` ran without changes
+- [ ] `cargo clippy --all-targets --all-features -- -D warnings` is clean
+- [ ] `cargo test -- --test-threads=1` passes
+- [ ] Complexity checks pass for new code (`cargo test complexity -- --nocapture`)
+- [ ] All new functions/methods have rustdoc comments (What, Inputs, Output, Details)
+- [ ] No `unwrap()` or `expect()` in non-test code
+
+**Testing:**
+- [ ] Added or updated tests where it makes sense
+- [ ] For bug fixes: created failing tests first, then fixed the issue
+- [ ] Tests are meaningful and cover the functionality
+
+**Documentation:**
+- [ ] Updated README if behavior, options, or keybinds changed (keep high-level, reference wiki)
+- [ ] Updated relevant wiki pages if needed
+- [ ] Updated config examples in `config/` directory if config keys changed
+- [ ] For UI changes: included screenshots and updated `Images/` if applicable
+
+**Compatibility:**
+- [ ] Changes respect `--dry-run` flag
+- [ ] Code degrades gracefully if `pacman`/`paru`/`yay` are unavailable
+- [ ] No breaking changes (or clearly documented if intentional)
+
+**Other:**
+- [ ] Not a packaging change for AUR (otherwise propose in `pacsea-bin` or `pacsea-git` repos)
+
+## Notes for reviewers
+
+- Minimal behavioural change: only additional key codes (`Char('\n')`, `Char('\r')`) are treated as submit; main Enter and existing behaviour unchanged.
+- `\n` and `\r` are control characters, so they were already not inserted into the password buffer; this change only makes them trigger submit.
+- Consistency pass: same Enter semantics applied in search, modals, recent, and install so numpad Enter behaves uniformly.
+- Design/analysis is documented in `dev/IMPROVEMENTS/ISSUE_119_NUMPAD_ENTER_PASSWORD_PROMPT.md`.
+
+## Breaking changes
+
+None.
+
+## Additional context
+
+- Issue: [Firstp1ck/Pacsea#119](https://github.com/Firstp1ck/Pacsea/issues/119)
+- Crossterm has no `NumpadEnter`; numpad Enter is reported as `KeyCode::Enter` or `KeyCode::Char('\r')` / `KeyCode::Char('\n')` depending on terminal/OS.

src/app/runtime/tick_handler.rs

@@ -16,6 +16,47 @@ use super::super::persist::{
     maybe_flush_services_cache,
 };
 use super::super::recent::{maybe_save_news_recent, maybe_save_recent};
+use crate::install::ExecutorRequest;
+
+/// What: Queue AUR update after system update success when pacman + AUR were both selected.
+///
+/// Inputs:
+/// - `app`: Mutable application state
+///
+/// Output: None
+///
+/// Details:
+/// - When `PreflightExec` shows success, items are empty (system update), and pending AUR command
+///   is set, queues the AUR command and updates the modal log. Called from tick to avoid borrow
+///   conflict in `event_loop`.
+fn maybe_queue_aur_after_system_update_success(app: &mut AppState) {
+    let (success_is_true, items_empty) =
+        if let crate::state::Modal::PreflightExec { success, items, .. } = &app.modal {
+            (success == &Some(true), items.is_empty())
+        } else {
+            (false, false)
+        };
+    if !success_is_true || !items_empty || app.pending_aur_update_command.is_none() {
+        return;
+    }
+    let aur_cmd = app.pending_aur_update_command.take();
+    let password = app.pending_executor_password.take();
+    if let (Some(aur_cmd), Some(password)) = (aur_cmd, password) {
+        app.pending_executor_request = Some(ExecutorRequest::Update {
+            commands: vec![aur_cmd],
+            password: Some(password),
+            dry_run: app.dry_run,
+        });
+        if let crate::state::Modal::PreflightExec {
+            log_lines, success, ..
+        } = &mut app.modal
+        {
+            log_lines.push(String::new());
+            log_lines.push("Running AUR update...".to_string());
+            *success = None;
+        }
+    }
+}
 
 /// What: Handle PKGBUILD result event.
 ///
@@ -649,6 +690,8 @@ pub fn handle_tick(
         summary_req_tx,
     );
 
+    maybe_queue_aur_after_system_update_success(app);
+
     // Send pending executor request if PreflightExec modal is active
     if let Some(request) = app.pending_executor_request.take()
         && matches!(app.modal, crate::state::Modal::PreflightExec { .. })
@@ -794,6 +837,9 @@ pub fn handle_status(app: &mut AppState, txt: &str, color: ArchStatusColor) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::install::ExecutorRequest;
+    use crate::state::Modal;
+    use crate::state::modal::{PreflightAction, PreflightTab};
 
     /// What: Provide a baseline `AppState` for tick handler tests.
     ///
@@ -927,6 +973,95 @@ mod tests {
         assert!(app.preflight_sandbox_items.is_none());
     }
 
+    #[test]
+    /// What: Verify AUR update is queued after system update success when pacman + AUR were selected.
+    ///
+    /// Inputs:
+    /// - `AppState` with `PreflightExec` (success, empty items), `pending_aur_update_command`,
+    ///   and `pending_executor_password` set; tick handler called.
+    ///
+    /// Output:
+    /// - `pending_executor_request` is `Some(Update { commands: [aur_cmd], ... })`,
+    ///   `pending_aur_update_command` is `None`, modal log contains "Running AUR update...".
+    ///
+    /// Details:
+    /// - Ensures "Update system" with all selections (including AUR) runs AUR after pacman succeeds.
+    fn handle_tick_queues_aur_after_system_update_success() {
+        let mut app = new_app();
+        let aur_cmd = "paru -Sua --noconfirm".to_string();
+        app.modal = Modal::PreflightExec {
+            items: vec![],
+            action: PreflightAction::Install,
+            tab: PreflightTab::Summary,
+            verbose: false,
+            log_lines: vec!["Done.".to_string()],
+            abortable: false,
+            header_chips: crate::state::modal::PreflightHeaderChips::default(),
+            success: Some(true),
+        };
+        app.pending_aur_update_command = Some(aur_cmd.clone());
+        app.pending_executor_password = Some("pass".to_string());
+
+        let (query_tx, _query_rx) = mpsc::unbounded_channel();
+        let (details_tx, _details_rx) = mpsc::unbounded_channel();
+        let (pkgb_tx, _pkgb_rx) = mpsc::unbounded_channel();
+        let (deps_tx, _deps_rx) = mpsc::unbounded_channel();
+        let (files_tx, _files_rx) = mpsc::unbounded_channel();
+        let (services_tx, _services_rx) = mpsc::unbounded_channel();
+        let (sandbox_tx, _sandbox_rx) = mpsc::unbounded_channel();
+        let (summary_tx, _summary_rx) = mpsc::unbounded_channel();
+        let (updates_tx, _updates_rx) = mpsc::unbounded_channel();
+        let (executor_req_tx, mut executor_req_rx) = mpsc::unbounded_channel();
+        let (post_summary_tx, _post_summary_rx) = mpsc::unbounded_channel();
+        let (news_content_tx, _news_content_rx) = mpsc::unbounded_channel();
+
+        handle_tick(
+            &mut app,
+            &query_tx,
+            &details_tx,
+            &pkgb_tx,
+            &deps_tx,
+            &files_tx,
+            &services_tx,
+            &sandbox_tx,
+            &summary_tx,
+            &updates_tx,
+            &executor_req_tx,
+            &post_summary_tx,
+            &news_content_tx,
+        );
+
+        assert!(
+            app.pending_aur_update_command.is_none(),
+            "pending_aur_update_command should be taken when AUR is queued"
+        );
+        let request = executor_req_rx
+            .try_recv()
+            .expect("executor should receive Update request with AUR command");
+        match &request {
+            ExecutorRequest::Update {
+                commands, password, ..
+            } => {
+                assert_eq!(commands.len(), 1);
+                assert_eq!(commands[0], aur_cmd);
+                assert_eq!(password.as_deref(), Some("pass"));
+            }
+            _ => panic!("expected ExecutorRequest::Update, got {request:?}"),
+        }
+        if let Modal::PreflightExec {
+            log_lines, success, ..
+        } = &app.modal
+        {
+            assert!(
+                log_lines.iter().any(|l| l == "Running AUR update..."),
+                "modal log should contain 'Running AUR update...'"
+            );
+            assert!(success.is_none(), "success should be cleared for AUR run");
+        } else {
+            panic!("modal should still be PreflightExec");
+        }
+    }
+
     #[test]
     /// What: Verify that `handle_tick` processes `PKGBUILD` reload debouncing.
     ///

src/events/modals/handlers.rs

@@ -1060,6 +1060,15 @@ pub(super) fn handle_password_prompt_modal(
             // Handle Update purpose with pending_update_commands
             if matches!(purpose, crate::state::modal::PasswordPurpose::Update) {
                 if let Some(commands) = app.pending_update_commands.take() {
+                    // Store password and header_chips so AUR update can run after pacman succeeds,
+                    // or so ConfirmAurUpdate can run AUR if pacman fails
+                    match (&mut app.pending_executor_password, &password) {
+                        (Some(p), Some(pass)) => p.clone_from(pass),
+                        (None, Some(pass)) => app.pending_executor_password = Some(pass.clone()),
+                        (_, None) => app.pending_executor_password = None,
+                    }
+                    app.pending_exec_header_chips = Some(header_chips.clone());
+
                     // Transition to PreflightExec for system update
                     app.modal = Modal::PreflightExec {
                         items: Vec::new(), // System update doesn't have package items

src/events/modals/tests/alert.rs

@@ -65,7 +65,7 @@ fn alert_enter_closes_modal() {
 ///
 /// Inputs:
 /// - Alert modal with message
-/// - KeyCode::Char('\r') (numpad Enter on some terminals)
+/// - `KeyCode::Char`('\r') (numpad Enter on some terminals)
 ///
 /// Output:
 /// - Modal is set to None
@@ -88,7 +88,7 @@ fn alert_numpad_enter_carriage_return_closes_modal() {
 ///
 /// Inputs:
 /// - Alert modal with message
-/// - KeyCode::Char('\n') (numpad Enter on some terminals)
+/// - `KeyCode::Char`('\n') (numpad Enter on some terminals)
 ///
 /// Output:
 /// - Modal is set to None

src/events/modals/tests/confirm.rs

@@ -114,17 +114,17 @@ fn confirm_remove_enter_closes_modal() {
 }
 
 #[test]
-/// What: Verify numpad Enter (carriage return) closes ConfirmRemove modal like main Enter.
+/// What: Verify numpad Enter (carriage return) closes `ConfirmRemove` modal like main Enter.
 ///
 /// Inputs:
-/// - ConfirmRemove modal
-/// - KeyCode::Char('\r')
+/// - `ConfirmRemove` modal
+/// - `KeyCode::Char`('\r')
 ///
 /// Output:
 /// - Modal is set to None
 ///
 /// Details:
-/// - Ensures numpad Enter handling does not break ConfirmRemove; same outcome as main Enter
+/// - Ensures numpad Enter handling does not break `ConfirmRemove`; same outcome as main Enter
 fn confirm_remove_numpad_enter_carriage_return_closes_modal() {
     let mut app = new_app();
     app.modal = crate::state::Modal::ConfirmRemove {
@@ -145,17 +145,17 @@ fn confirm_remove_numpad_enter_carriage_return_closes_modal() {
 }
 
 #[test]
-/// What: Verify numpad Enter (newline) closes ConfirmRemove modal like main Enter.
+/// What: Verify numpad Enter (newline) closes `ConfirmRemove` modal like main Enter.
 ///
 /// Inputs:
-/// - ConfirmRemove modal
-/// - KeyCode::Char('\n')
+/// - `ConfirmRemove` modal
+/// - `KeyCode::Char`('\n')
 ///
 /// Output:
 /// - Modal is set to None
 ///
 /// Details:
-/// - Ensures numpad Enter handling does not break ConfirmRemove; same outcome as main Enter
+/// - Ensures numpad Enter handling does not break `ConfirmRemove`; same outcome as main Enter
 fn confirm_remove_numpad_enter_newline_closes_modal() {
     let mut app = new_app();
     app.modal = crate::state::Modal::ConfirmRemove {

src/events/modals/tests/help.rs

@@ -61,7 +61,7 @@ fn help_enter_closes_modal() {
 ///
 /// Inputs:
 /// - Help modal
-/// - KeyCode::Char('\r')
+/// - `KeyCode::Char`('\r')
 ///
 /// Output:
 /// - Modal is set to None
@@ -82,7 +82,7 @@ fn help_numpad_enter_carriage_return_closes_modal() {
 ///
 /// Inputs:
 /// - Help modal
-/// - KeyCode::Char('\n')
+/// - `KeyCode::Char`('\n')
 ///
 /// Output:
 /// - Modal is set to None

src/events/modals/tests/news.rs

@@ -211,7 +211,7 @@ fn news_enter_preserves_modal() {
 ///
 /// Inputs:
 /// - News modal with item
-/// - KeyCode::Char('\r')
+/// - `KeyCode::Char`('\r')
 ///
 /// Output:
 /// - Modal remains News, selected unchanged
@@ -231,7 +231,7 @@ fn news_numpad_enter_carriage_return_keeps_modal_open() {
     }];
     let mut app = new_app();
     app.modal = crate::state::Modal::News {
-        items: items.clone(),
+        items,
         selected: 0,
         scroll: 0,
     };
@@ -249,7 +249,7 @@ fn news_numpad_enter_carriage_return_keeps_modal_open() {
 ///
 /// Inputs:
 /// - News modal with item
-/// - KeyCode::Char('\n')
+/// - `KeyCode::Char`('\n')
 ///
 /// Output:
 /// - Modal remains News, selected unchanged
@@ -269,7 +269,7 @@ fn news_numpad_enter_newline_keeps_modal_open() {
     }];
     let mut app = new_app();
     app.modal = crate::state::Modal::News {
-        items: items.clone(),
+        items,
         selected: 0,
         scroll: 0,
     };