Add "!!" for running commands with output addition suppressed and "!!!" to background the tui for commands that require input

Author: Your Name

cecli/coders/base_coder.py

@@ -1693,13 +1693,27 @@ async def preproc_user_input(self, inp):
         inp = inp.strip()
 
         if self.commands.is_command(inp):
+            run_kwargs = {}
             if inp[0] in "!":
-                inp = f"/run {inp[1:]}"
+                # Count and strip all leading exclamation marks
+                # "!command" -> normal execution
+                # "!!command" -> suppress adding output to chat
+                # "!!!command" -> background/obstructive mode (TUI suspended)
+                num_marks = 0
+                while num_marks < len(inp) and inp[num_marks] == "!":
+                    num_marks += 1
+                command_text = inp[num_marks:]
+                inp = f"/run {command_text}"
+                if num_marks >= 3:
+                    run_kwargs["background"] = True
+                    run_kwargs["suppress_add"] = True
+                elif num_marks == 2:
+                    run_kwargs["suppress_add"] = True
 
             if self.commands.is_run_command(inp):
                 self.commands.cmd_running_event.clear()  # Command is running
 
-            return await self.commands.run(inp, coder=self)
+            return await self.commands.run(inp, coder=self, **run_kwargs)
 
         await self.check_for_file_mentions(inp)
         inp = await self.check_for_urls(inp)

cecli/commands/core.py

@@ -232,7 +232,13 @@ def matching_commands(self, inp):
         matching_commands = [cmd for cmd in all_commands if cmd.startswith(first_word)]
         return matching_commands, first_word, rest_inp
 
-    async def run(self, inp, coder=None):
+    async def run(self, inp, coder=None, **kwargs):
+        if inp.startswith("!!!"):
+            return await self.execute(
+                "run", inp[3:], coder=coder, background=True, suppress_add=True
+            )
+        if inp.startswith("!!"):
+            return await self.execute("run", inp[2:], coder=coder, suppress_add=True)
         if inp.startswith("!"):
             return await self.execute("run", inp[1:], coder=coder)
         res = self.matching_commands(inp)
@@ -241,10 +247,10 @@ async def run(self, inp, coder=None):
         matching_commands, first_word, rest_inp = res
         if len(matching_commands) == 1:
             command = matching_commands[0][1:]
-            return await self.execute(command, rest_inp, coder=coder)
+            return await self.execute(command, rest_inp, coder=coder, **kwargs)
         elif first_word in matching_commands:
             command = first_word[1:]
-            return await self.execute(command, rest_inp, coder=coder)
+            return await self.execute(command, rest_inp, coder=coder, **kwargs)
         elif len(matching_commands) > 1:
             self.io.tool_error(f"Ambiguous command: {', '.join(matching_commands)}")
         else:

cecli/commands/run.py

@@ -14,8 +14,14 @@ class RunCommand(BaseCommand):
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         """Execute the run command with given parameters."""
+        suppress_add = kwargs.get("suppress_add", False)
+        background = kwargs.get("background", False)
         add_on_nonzero_exit = kwargs.get("add_on_nonzero_exit", False)
 
+        # Background mode: suspend the TUI and run interactively
+        if background:
+            return await cls._execute_background(io, coder, args)
+
         should_print = True
 
         if coder.args.tui:
@@ -44,7 +50,10 @@ async def execute(cls, io, coder, args, **kwargs):
         token_count = coder.main_model.token_count(combined_output)
         k_tokens = token_count / 1000
 
-        if add_on_nonzero_exit:
+        # When suppress_add is True, skip the confirmation and never add
+        if suppress_add:
+            add = False
+        elif add_on_nonzero_exit:
             add = exit_status != 0
         else:
             add = await io.confirm_ask(f"Add {k_tokens:.1f}k tokens of command output to the chat?")
@@ -80,6 +89,35 @@ async def execute(cls, io, coder, args, **kwargs):
         # Return None if output wasn't added or command succeeded
         return format_command_result(io, "run", "Command executed successfully")
 
+    @classmethod
+    async def _execute_background(cls, io, coder, args):
+        """
+        Execute a command in background/obstructive mode with the TUI suspended.
+
+        This allows running interactive commands (e.g., sudo) that require
+        direct terminal access for user input. The TUI is suspended while
+        the command runs and is resumed upon completion.
+        """
+        import subprocess
+
+        def _run_sync():
+            """Run the command synchronously with direct terminal access."""
+            subprocess.run(
+                args,
+                shell=True,
+                cwd=coder.root,
+            )
+
+        if coder.tui and coder.tui():
+            # Suspend the TUI and run the command with direct terminal access
+            coder.tui().run_obstructive(_run_sync)
+        else:
+            # Not in TUI mode, run directly
+            _run_sync()
+
+        io.tool_output(f"Background command completed: {args}")
+        return format_command_result(io, "run", "Command executed in background mode")
+
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
         """Get completion options for run command."""