fix: Ctrl+C double-exit in interactive shell (Tracer-Cloud#1105)

jason8745 · web-flow · commit 72dd2cce5583 · 2026-04-30T11:31:47.000+01:00
* fix: Ctrl+C double-exit in interactive shell (first press hints, second exits) Implements the two-press Ctrl+C exit pattern: the first Ctrl+C displays "(Press Ctrl+C again to exit)" and re-displays the prompt; the second Ctrl+C within 2 seconds prints "Goodbye!" and exits cleanly (code 0). - Add `_with_ctrl_c_double_exit()` wrapping `question.unsafe_ask()` in a retry loop — avoids key-binding conflicts that caused the sentinel approach to fail - Add `_HardQuitInterrupt(KeyboardInterrupt)` so Ctrl+Q hard-quit bypasses the retry guard - Restore explicit ControlC binding in wizard `_base_bindings()` because `InquirerControl` is not a `BufferControl`, making prompt_toolkit's default Ctrl+C binding inactive for custom wizard prompts - Install a SIGINT handler in `main()` for between-prompt Ctrl+C - Add/update unit tests in `tests/cli/test_prompt_support.py` - Fix smoke test to use Escape (PTY-safe) instead of Ctrl+C Fixes Tracer-Cloud#1091 * fix: add questionary.password to Ctrl+C double-exit and Escape-cancel patches * fix: use None sentinel for _last_ctrl_c to make never-pressed state explicit * fix: print newline on unhandled KeyboardInterrupt in main() for clean terminal output * fix: reset _last_ctrl_c after successful prompt return to prevent cross-prompt leakage
diff --git a/app/cli/__main__.py b/app/cli/__main__.py
@@ -10,6 +10,7 @@
 from __future__ import annotations
 
 import os
+import signal
 import sys
 
 import click
@@ -19,7 +20,11 @@
 from app.analytics.provider import capture_first_run_if_needed, shutdown_analytics
 from app.cli.commands import register_commands
 from app.cli.layout import RichGroup, render_landing
-from app.cli.prompt_support import install_questionary_escape_cancel
+from app.cli.prompt_support import (
+    handle_ctrl_c_press,
+    install_questionary_ctrl_c_double_exit,
+    install_questionary_escape_cancel,
+)
 from app.version import get_version
 
 
@@ -87,14 +92,37 @@ def cli(
 register_commands(cli)
 
 
+def _install_sigint_handler() -> None:
+    """Handle Ctrl+C between prompts (when prompt_toolkit is not active).
+
+    prompt_toolkit intercepts Ctrl+C internally while a prompt is running, so
+    the key binding in prompt_support.py handles that case.  This SIGINT handler
+    covers everything else: long-running operations, streaming output, etc.
+    """
+
+    def _handler(signum: int, frame: object) -> None:  # noqa: ARG001
+        handle_ctrl_c_press()
+
+    signal.signal(signal.SIGINT, _handler)
+
+
 def main(argv: list[str] | None = None) -> int:
     """Entry point for the ``opensre`` console script."""
     load_dotenv(override=False)
     install_questionary_escape_cancel()
+    install_questionary_ctrl_c_double_exit()
+    _install_sigint_handler()
     capture_first_run_if_needed()
 
     try:
         cli(args=argv, standalone_mode=True)
+    except KeyboardInterrupt:
+        # A KeyboardInterrupt that escapes cli() was not handled by our
+        # double-exit logic (e.g. click.prompt, an unpatched library prompt).
+        # Print a newline so the terminal cursor lands on a clean line, then
+        # exit quietly — Click's "Aborted!" message is intentionally suppressed.
+        print(flush=True)
+        return 0
     except SystemExit as exc:
         if isinstance(exc.code, int):
             return exc.code
diff --git a/app/cli/prompt_support.py b/app/cli/prompt_support.py
@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import sys
+import time
 from collections.abc import Callable
 from typing import Any
 
@@ -10,6 +12,15 @@
 from prompt_toolkit.keys import Keys
 
 _escape_patch_installed: list[bool] = [False]
+_ctrl_c_patch_installed: list[bool] = [False]
+
+# Shared timestamp of the last Ctrl+C press (None = never pressed).
+_last_ctrl_c: list[float | None] = [None]
+_CTRL_C_EXIT_WINDOW: float = 2.0
+
+
+class _HardQuitInterrupt(KeyboardInterrupt):
+    """Raised by explicit quit keys (Ctrl+Q) to bypass the Ctrl+C double-exit guard."""
 
 
 def _with_escape_cancel(question: questionary.question.Question) -> questionary.question.Question:
@@ -46,6 +57,7 @@ def install_questionary_escape_cancel() -> None:
     import questionary
     import questionary.prompts.checkbox as checkbox_mod
     import questionary.prompts.confirm as confirm_mod
+    import questionary.prompts.password as password_mod
     import questionary.prompts.path as path_mod
     import questionary.prompts.select as select_mod
     import questionary.prompts.text as text_mod
@@ -55,11 +67,108 @@ def install_questionary_escape_cancel() -> None:
     confirm_mod.confirm = _wrap_question_prompt(confirm_mod.confirm)
     text_mod.text = _wrap_question_prompt(text_mod.text)
     path_mod.path = _wrap_question_prompt(path_mod.path)
+    password_mod.password = _wrap_question_prompt(password_mod.password)
 
     questionary.select = select_mod.select
     questionary.checkbox = checkbox_mod.checkbox
     questionary.confirm = confirm_mod.confirm
     questionary.text = text_mod.text
     questionary.path = path_mod.path
+    questionary.password = password_mod.password
 
     _escape_patch_installed[0] = True
+
+
+def handle_ctrl_c_press() -> None:
+    """Handle Ctrl+C from the SIGINT signal handler (between prompts).
+
+    First call:  prints hint.
+    Second call within _CTRL_C_EXIT_WINDOW seconds:  prints Goodbye and exits.
+    """
+    now = time.monotonic()
+    if _last_ctrl_c[0] is not None and now - _last_ctrl_c[0] <= _CTRL_C_EXIT_WINDOW:
+        print("\nGoodbye!", flush=True)
+        sys.exit(0)
+    _last_ctrl_c[0] = now
+    print("\n(Press Ctrl+C again to exit)", flush=True)
+
+
+def _with_ctrl_c_double_exit(
+    question: questionary.question.Question,
+) -> questionary.question.Question:
+    """Add Ctrl+C double-exit handling to a questionary prompt.
+
+    Patches question.ask() to call unsafe_ask() (which does NOT swallow
+    KeyboardInterrupt) in a retry loop.  On the first Ctrl+C the hint is
+    printed and the prompt is re-displayed; on the second Ctrl+C within
+    _CTRL_C_EXIT_WINDOW seconds the process exits.
+
+    We do NOT add extra key bindings — the prompt_toolkit default Ctrl+C
+    binding already raises KeyboardInterrupt from application.run(), and
+    fighting it with another eager binding causes unpredictable ordering.
+    """
+
+    def _patched_ask(*args: Any, **kwargs: Any) -> Any:
+        while True:
+            try:
+                # unsafe_ask() propagates KeyboardInterrupt instead of
+                # swallowing it the way ask() does.
+                result = question.unsafe_ask(*args, **kwargs)
+                _last_ctrl_c[0] = None  # reset on clean exit so next prompt starts fresh
+                return result
+            except KeyboardInterrupt as exc:
+                if isinstance(exc, _HardQuitInterrupt):
+                    raise  # Ctrl+Q hard-quit — bypass retry logic
+                now = time.monotonic()
+                if _last_ctrl_c[0] is not None and now - _last_ctrl_c[0] <= _CTRL_C_EXIT_WINDOW:
+                    print("\nGoodbye!", flush=True)
+                    sys.exit(0)
+                _last_ctrl_c[0] = now
+                print("\n(Press Ctrl+C again to exit)", flush=True)
+                # Loop: re-run the same application (Application.run() is
+                # safe to call again after a clean exit or KeyboardInterrupt).
+
+    question.ask = _patched_ask  # type: ignore[method-assign]
+    return question
+
+
+def _wrap_question_ctrl_c(
+    orig: Callable[..., questionary.question.Question],
+) -> Callable[..., questionary.question.Question]:
+    def wrapped(*args: Any, **kwargs: Any) -> questionary.question.Question:
+        return _with_ctrl_c_double_exit(orig(*args, **kwargs))
+
+    wrapped.__name__ = orig.__name__
+    wrapped.__doc__ = orig.__doc__
+    wrapped.__qualname__ = getattr(orig, "__qualname__", orig.__name__)
+    return wrapped
+
+
+def install_questionary_ctrl_c_double_exit() -> None:
+    """Make Ctrl+C show a hint on first press and exit on second press within 2 s."""
+    if _ctrl_c_patch_installed[0]:
+        return
+
+    import questionary
+    import questionary.prompts.checkbox as checkbox_mod
+    import questionary.prompts.confirm as confirm_mod
+    import questionary.prompts.password as password_mod
+    import questionary.prompts.path as path_mod
+    import questionary.prompts.select as select_mod
+    import questionary.prompts.text as text_mod
+
+    select_mod.select = _wrap_question_ctrl_c(select_mod.select)
+    checkbox_mod.checkbox = _wrap_question_ctrl_c(checkbox_mod.checkbox)
+    confirm_mod.confirm = _wrap_question_ctrl_c(confirm_mod.confirm)
+    text_mod.text = _wrap_question_ctrl_c(text_mod.text)
+    path_mod.path = _wrap_question_ctrl_c(path_mod.path)
+    password_mod.password = _wrap_question_ctrl_c(password_mod.password)
+
+    questionary.select = select_mod.select
+    questionary.checkbox = checkbox_mod.checkbox
+    questionary.confirm = confirm_mod.confirm
+    questionary.text = text_mod.text
+    questionary.path = path_mod.path
+    questionary.password = password_mod.password
+
+    _ctrl_c_patch_installed[0] = True
diff --git a/app/cli/wizard/prompts.py b/app/cli/wizard/prompts.py
@@ -20,6 +20,8 @@
 from questionary.question import Question
 from questionary.styles import merge_styles_default
 
+from app.cli.prompt_support import _HardQuitInterrupt, _with_ctrl_c_double_exit
+
 
 class _CheckboxControl(InquirerControl):
     """Render checked items neutrally unless they are the active row."""
@@ -104,8 +106,15 @@ def _base_bindings(
     bindings = KeyBindings()
 
     @bindings.add(Keys.ControlQ, eager=True)
+    def _quit(event: Any) -> None:
+        # ControlQ is an intentional hard-quit; use _HardQuitInterrupt so the
+        # Ctrl+C double-exit retry loop does not swallow this as a first press.
+        event.app.exit(exception=_HardQuitInterrupt(), style="class:aborting")
+
     @bindings.add(Keys.ControlC, eager=True)
-    def _abort(event: Any) -> None:
+    def _ctrl_c(event: Any) -> None:
+        # Raise KeyboardInterrupt so the double-exit logic in _with_ctrl_c_double_exit
+        # can implement hint-on-first / exit-on-second behavior via the retry loop.
         event.app.exit(exception=KeyboardInterrupt, style="class:aborting")
 
     def _move_down(_event: Any) -> None:
@@ -207,17 +216,19 @@ def _submit(event: Any) -> None:
         ic.is_answered = True
         event.app.exit(result=ic.get_pointed_at().value)
 
-    return Question(
-        Application(
-            layout=common.create_inquirer_layout(
-                ic,
-                _tokens,
-                **_layout_kwargs(input=input, output=output),
-            ),
-            key_bindings=bindings,
-            style=merge_styles_default([style]),
-            input=input,
-            output=output,
+    return _with_ctrl_c_double_exit(
+        Question(
+            Application(
+                layout=common.create_inquirer_layout(
+                    ic,
+                    _tokens,
+                    **_layout_kwargs(input=input, output=output),
+                ),
+                key_bindings=bindings,
+                style=merge_styles_default([style]),
+                input=input,
+                output=output,
+            )
         )
     )
 
@@ -272,16 +283,18 @@ def _submit(event: Any) -> None:
         ic.is_answered = True
         event.app.exit(result=[choice.value for choice in ic.get_selected_values()])
 
-    return Question(
-        Application(
-            layout=common.create_inquirer_layout(
-                ic,
-                _tokens,
-                **_layout_kwargs(input=input, output=output),
-            ),
-            key_bindings=bindings,
-            style=merge_styles_default([style]),
-            input=input,
-            output=output,
+    return _with_ctrl_c_double_exit(
+        Question(
+            Application(
+                layout=common.create_inquirer_layout(
+                    ic,
+                    _tokens,
+                    **_layout_kwargs(input=input, output=output),
+                ),
+                key_bindings=bindings,
+                style=merge_styles_default([style]),
+                input=input,
+                output=output,
+            )
         )
     )
diff --git a/tests/cli/test_prompt_support.py b/tests/cli/test_prompt_support.py
@@ -1,10 +1,18 @@
 from __future__ import annotations
 
+import time
+
+import pytest
 import questionary
 from prompt_toolkit.input.defaults import create_pipe_input  # type: ignore[import-not-found]
 from prompt_toolkit.output import DummyOutput  # type: ignore[import-not-found]
 
-from app.cli.prompt_support import install_questionary_escape_cancel
+from app.cli.prompt_support import (
+    _last_ctrl_c,
+    handle_ctrl_c_press,
+    install_questionary_ctrl_c_double_exit,
+    install_questionary_escape_cancel,
+)
 
 
 def test_install_questionary_escape_cancel_is_idempotent() -> None:
@@ -28,3 +36,46 @@ def test_stock_questionary_select_escape_cancels() -> None:
         app.input = pipe_input
         app.output = DummyOutput()
         assert app.run() is None
+
+
+def test_install_questionary_ctrl_c_double_exit_is_idempotent() -> None:
+    install_questionary_ctrl_c_double_exit()
+    first = questionary.select
+    install_questionary_ctrl_c_double_exit()
+    assert questionary.select is first
+
+
+def test_ctrl_c_first_press_shows_hint_and_reprompts(capsys) -> None:
+    """First Ctrl+C prints the hint and re-displays the prompt; Enter then submits."""
+    _last_ctrl_c[0] = None
+    install_questionary_ctrl_c_double_exit()
+    with create_pipe_input() as pipe_input:
+        q = questionary.select(
+            "Pick",
+            choices=["a", "b"],
+            input=pipe_input,
+            output=DummyOutput(),
+        )
+        # Ctrl+C cancels the first run; Enter submits the re-displayed prompt.
+        pipe_input.send_bytes(b"\x03\r")
+        result = q.ask()
+    assert "(Press Ctrl+C again to exit)" in capsys.readouterr().out
+    # After the hint the prompt was re-run and "a" was selected (first choice).
+    assert result == "a"
+
+
+def test_ctrl_c_second_press_exits(capsys) -> None:
+    # Simulate a previous Ctrl+C just now so the second press fires immediately.
+    _last_ctrl_c[0] = time.monotonic()
+    with pytest.raises(SystemExit) as exc_info:
+        handle_ctrl_c_press()
+    assert exc_info.value.code == 0
+    assert "Goodbye" in capsys.readouterr().out
+
+
+def test_ctrl_c_hint_resets_after_window(capsys) -> None:
+    # A press older than the exit window should show the hint again, not exit.
+    _last_ctrl_c[0] = None  # effectively "long ago"
+    handle_ctrl_c_press()
+    out = capsys.readouterr().out
+    assert "(Press Ctrl+C again to exit)" in out
diff --git a/tests/cli_smoke_test.py b/tests/cli_smoke_test.py
@@ -612,10 +612,12 @@ def test_integrations_remove_datadog_interactive_smoke(cli_sandbox: CliSandbox)
 
 @pytest.mark.skipif(os.name == "nt", reason="interactive smoke uses POSIX PTYs")
 def test_tests_interactive_launcher_smoke(cli_sandbox: CliSandbox) -> None:
+    # The prompt instruction reads "Esc exit"; Escape is the PTY-safe way to
+    # dismiss the prompt in automation (no SIGINT/raw-mode race conditions).
     result = _run_cli_pty(
         cli_sandbox,
         "tests",
-        actions=[PtyAction(expect="Choose a test category:", send=b"\x03")],
+        actions=[PtyAction(expect="Choose a test category:", send=b"\x1b")],
     )
 
     assert result.exit_code == 0
