feat: keep one application running across prompt and command execution

Author: tleonhardt

cmd2/cmd2.py

@@ -2133,6 +2133,15 @@ def _command_toolbar_context(self) -> Iterator[None]:
                     # one would disable the toolbar for the rest of the session.
                     self._command_toolbar = None
 
+    @contextlib.contextmanager
+    def _command_mode_context(self) -> Iterator[None]:
+        """Show the command display while a command runs, if a toolbar is running."""
+        if self._command_toolbar is None:
+            yield
+        else:
+            with self._command_toolbar.command_mode():
+                yield
+
     def get_rprompt(self) -> AnyFormattedText:
         """Provide text to populate the prompt-toolkit right prompt.
 
@@ -3880,6 +3889,11 @@ def _pre_prompt() -> None:
                 self._alert_condition.notify_all()
 
         try:
+            # A running command display already owns the terminal and the application.
+            # Reading through it keeps that single run alive across the prompt, so the
+            # toolbar is never erased by an end-of-run frame.
+            if self._command_toolbar is not None and self._command_toolbar.is_active:
+                return self._command_toolbar.read_line(prompt_to_use, pre_run=_pre_prompt)
             return self._read_raw_input(
                 prompt=prompt_to_use,
                 session=self.main_session,
@@ -3899,27 +3913,31 @@ def _cmdloop(self) -> None:
         This serves the same role as cmd.cmdloop().
         """
         try:
-            # Run startup commands
-            if self._startup_commands:
-                with self._command_toolbar_context():
-                    stop = self.runcmds_plus_hooks(self._startup_commands)
-            else:
-                stop = False
-            self._startup_commands.clear()
+            # Hold one command display open for the whole loop. Starting and stopping
+            # it per command would end its application each time, and prompt-toolkit
+            # drops the bottom toolbar from the final frame of every run.
+            with self._command_toolbar_context():
+                # Run startup commands
+                if self._startup_commands:
+                    with self._command_mode_context():
+                        stop = self.runcmds_plus_hooks(self._startup_commands)
+                else:
+                    stop = False
+                self._startup_commands.clear()
 
-            while not stop:
-                # Get commands from user
-                try:
-                    line = self._read_command_line(self.prompt)
-                except KeyboardInterrupt:
-                    self.poutput("^C")
-                    line = ""
-                except EOFError:
-                    line = "_eof"
+                while not stop:
+                    # Get commands from user
+                    try:
+                        line = self._read_command_line(self.prompt)
+                    except KeyboardInterrupt:
+                        self.poutput("^C")
+                        line = ""
+                    except EOFError:
+                        line = "_eof"
 
-                # Run the command along with all associated pre and post hooks
-                with self._command_toolbar_context():
-                    stop = self.onecmd_plus_hooks(line)
+                    # Run the command along with all associated pre and post hooks
+                    with self._command_mode_context():
+                        stop = self.onecmd_plus_hooks(line)
         finally:
             with self.sigint_protection:
                 # Shut down the alert thread.

cmd2/command_toolbar.py

@@ -29,6 +29,7 @@
 
 if TYPE_CHECKING:
     from prompt_toolkit.buffer import Buffer
+    from prompt_toolkit.key_binding.key_bindings import KeyBindingsBase
 
     from .cmd2 import Cmd
 
@@ -226,7 +227,10 @@ def prompt_eof(event: KeyPressEvent) -> None:  # noqa: ARG001
         # display's set, so it is the PromptSession's own: completion, history, and
         # cmd2's bindings. Merging the overrides last lets them win, because
         # KeyProcessor calls matches[-1].
-        self._prompt_bindings = merge_key_bindings([session.app.key_bindings, prompt_bindings])
+        session_bindings = session.app.key_bindings
+        self._prompt_bindings: KeyBindingsBase = (
+            merge_key_bindings([session_bindings, prompt_bindings]) if session_bindings is not None else prompt_bindings
+        )
         self._line: Future[str] | None = None
         # Only swapped in for the duration of read_line(). session.prompt() still runs
         # nested prompts and the no-toolbar fallback, and those rely on the stock
@@ -464,6 +468,14 @@ def enter() -> None:
                 pre_run()
             self.app.invalidate()
 
+            # Keys typed while the command ran were swallowed by the save_key binding
+            # so they could not become commands mid-execution. Replay them now that a
+            # prompt is on screen and its bindings are active, in arrival order.
+            if self._keys:
+                pending, self._keys = self._keys, []
+                self.app.key_processor.feed_multiple(pending)
+                self.app.key_processor.process_keys()
+
         try:
             self._call_in_ui(enter)
             while True:
@@ -483,7 +495,7 @@ def enter() -> None:
     @staticmethod
     def _resolve_message(message: "PromptMessage") -> str:
         """Render the prompt to text for the scrollback echo."""
-        resolved = message() if callable(message) else message
+        resolved = message if isinstance(message, (ANSI, str)) else message()
         return resolved.value if isinstance(resolved, ANSI) else resolved
 
     def _echo_accepted(self, message: "PromptMessage", text: str) -> None:
@@ -496,6 +508,25 @@ def _echo_accepted(self, message: "PromptMessage", text: str) -> None:
         self.cmd.stdout.write(f"{self._resolve_message(message)}{text}\n")
         self.cmd.stdout.flush()
 
+    @contextlib.contextmanager
+    def command_mode(self) -> Iterator[None]:
+        """Swap to the toolbar-only layout while a command runs on the main thread."""
+
+        def enter() -> None:
+            self.app.layout = self._layout
+            self.app.key_bindings = self._bindings
+            self.app.invalidate()
+
+        self._call_in_ui(enter)
+        try:
+            yield
+        finally:
+            # Restore the command display if a nested prompt or the pager swapped the
+            # layout out. When the display has already stopped, _pause() has restored
+            # the borrowed application's own state and there is nothing to put back.
+            if self._thread is not None and self._thread.is_alive():
+                self._call_in_ui(enter)
+
     def page(self, text: str, *, chop: bool) -> None:
         """Show a pager above the same toolbar without starting another input reader."""
         size = self.app.output.get_size()

tests/test_command_toolbar.py

@@ -856,3 +856,19 @@ def test_read_line_echoes_the_accepted_line(toolbar_app) -> None:
         pipe.send_text("hello\n")
         assert toolbar.read_line(ANSI("myapp> ")) == "hello"
     assert output.getvalue().count("myapp> hello") == 1
+
+
+def test_typeahead_during_a_command_reaches_the_next_prompt(toolbar_app) -> None:
+    """Keys typed while a command runs are handled by the prompt that follows it."""
+    app, pipe, _ = toolbar_app
+
+    def slow(_) -> None:
+        pipe.send_text("typed\n")
+        time.sleep(0.2)
+
+    app.do_slow = slow
+    with app._command_toolbar_context():
+        toolbar = app._command_toolbar
+        with app._command_mode_context():
+            app.onecmd_plus_hooks("slow")
+        assert toolbar.read_line(ANSI("> ")) == "typed"

tests/test_toolbar_flicker.py

@@ -32,9 +32,12 @@ def record(rendered_app) -> None:
     app.do_probe = lambda _: None
     try:
         pipe.send_text("probe\n")
-        line = app._read_command_line(app.prompt)
+        # Mirror _cmdloop: one display held open across both the prompt and the
+        # command, rather than started and stopped around each command.
         with app._command_toolbar_context():
-            app.onecmd_plus_hooks(line)
+            line = app._read_command_line(app.prompt)
+            with app._command_mode_context():
+                app.onecmd_plus_hooks(line)
     finally:
         ui.after_render.remove_handler(record)