feat(assistant): show and manage pending command state

Author: maxDcb

C2Client/C2Client/AssistantPanel.py

@@ -132,10 +132,18 @@ def consoleAssistantMethod(self, action, beaconHash, listenerHash, context, cmd,
 
         if awaiting_result:
             pending_id = self.pending_tool_id
+            tool_output = self._format_tool_result_for_resume(
+                beacon_hash=beaconHash,
+                listener_hash=listenerHash,
+                command_id=commandId,
+                command=command_text,
+                output=display_output,
+            )
+            self.printInTerminal("Analysis:", f"Received result for command `{commandId or command_text}`. Resuming assistant.")
             self._clear_pending_tool_state()
 
             if pending_id:
-                self._start_agent_resume(pending_id, display_output)
+                self._start_agent_resume(pending_id, tool_output)
         else:
             combined = command_text
             if output_text:
@@ -149,6 +157,20 @@ def consoleAssistantMethod(self, action, beaconHash, listenerHash, context, cmd,
                     output=output_text,
                 )
 
+
+    def _format_tool_result_for_resume(self, *, beacon_hash, listener_hash, command_id, command, output):
+        return "\n".join(
+            [
+                "Command result received from TeamServer.",
+                f"command_id: {command_id or 'unknown'}",
+                f"beacon_hash: {beacon_hash or 'unknown'}",
+                f"listener_hash: {listener_hash or 'unknown'}",
+                f"command: {command or 'unknown'}",
+                "output:",
+                output or "[no output]",
+            ]
+        )
+
     def event(self, event):
         if event.type() == QEvent.Type.KeyPress and event.key() == Qt.Key.Key_Tab:
             self.tabPressed.emit()
@@ -193,7 +215,15 @@ def runCommand(self):
             self._show_local_help()
             return
 
+        if local_command == "/status":
+            self._show_pending_status()
+            return
+
         if local_command in {"/cancel", "/reset"}:
+            if not self.awaiting_tool_result:
+                self.printInTerminal("Analysis:", "No pending command wait to cancel.")
+                return
+
             self._clear_pending_tool_state()
             self.printInTerminal("Analysis:", "Pending command wait cancelled.")
             return
@@ -228,6 +258,7 @@ def _show_local_help(self):
             "\n".join(
                 [
                     "/help - Show AssistantPanel local commands.",
+                    "/status - Show the current assistant pending command state.",
                     "/cancel - Cancel the current pending beacon result wait.",
                     "/reset - Alias for /cancel.",
                     timeout_line,
@@ -236,6 +267,44 @@ def _show_local_help(self):
         )
 
 
+    def _show_pending_status(self):
+        self.printInTerminal("Analysis:", self._format_pending_status())
+
+
+    def _format_pending_status(self, prefix=None):
+        if not self.awaiting_tool_result:
+            with self._response_lock:
+                busy = self._response_thread is not None and self._response_thread.is_alive()
+            if busy:
+                return "Assistant is processing a request. No beacon command result is pending yet."
+            return "No pending beacon command result."
+
+        context = self.pending_tool_context or {}
+        command = context.get("command_line") or "unknown command"
+        command_id = context.get("command_id") or "unknown"
+        beacon_hash = context.get("beacon_hash") or "unknown"
+        listener_hash = context.get("listener_hash") or "unknown"
+
+        lines = []
+        if prefix:
+            lines.append(prefix)
+        lines.extend(
+            [
+                f"Pending command: {command}",
+                f"Command ID: {command_id}",
+                f"Beacon: {beacon_hash}",
+                f"Listener: {listener_hash}",
+            ]
+        )
+
+        if self.pending_tool_timeout_ms > 0:
+            lines.append(f"Timeout: {self.pending_tool_timeout_ms // 1000}s")
+        else:
+            lines.append("Timeout: disabled")
+
+        return "\n".join(lines)
+
+
     def _start_agent_turn(self, user_input):
         with self._response_lock:
             if self._response_thread and self._response_thread.is_alive():
@@ -303,6 +372,7 @@ def _process_assistant_response(self, message):
                 "command_line": metadata.get("command_line") or arguments.get("command_line"),
             }
             self._start_pending_tool_timer()
+            self.printInTerminal("Analysis:", self._format_pending_status("Waiting for beacon command result."))
         else:
             self._stop_pending_tool_timer()
 
@@ -326,13 +396,15 @@ def _handle_pending_tool_timeout(self):
 
         context = self.pending_tool_context or {}
         command = context.get("command_line") or context.get("command_id") or "command"
+        command_id = context.get("command_id")
         beacon_hash = context.get("beacon_hash")
         target = f" on beacon {beacon_hash[:8]}" if beacon_hash else ""
+        command_id_text = f" Command ID: {command_id}." if command_id else ""
 
         self._clear_pending_tool_state()
         self.printInTerminal(
             "Analysis:",
-            f"Timed out waiting for result of `{command}`{target}. The assistant is ready for a new request.",
+            f"Timed out waiting for result of `{command}`{target}.{command_id_text} The assistant is ready for a new request.",
         )
 
     def _handle_assistant_error(self, error_message):

C2Client/tests/test_assistant_panel.py

@@ -66,6 +66,7 @@ def test_help_command_shows_local_commands(qtbot, monkeypatch):
     output = assistant.editorOutput.toPlainText()
     assert "Assistant commands:" in output
     assert "/help - Show AssistantPanel local commands." in output
+    assert "/status - Show the current assistant pending command state." in output
     assert "/cancel - Cancel the current pending beacon result wait." in output
     assert "/reset - Alias for /cancel." in output
 
@@ -96,6 +97,15 @@ def test_cancel_command_clears_pending_state(qtbot, monkeypatch):
     assert "Pending command wait cancelled." in assistant.editorOutput.toPlainText()
 
 
+def test_cancel_command_reports_when_nothing_is_pending(qtbot, monkeypatch):
+    assistant = build_assistant(qtbot, monkeypatch)
+
+    assistant.commandEditor.setText("/cancel")
+    assistant.runCommand()
+
+    assert "No pending command wait to cancel." in assistant.editorOutput.toPlainText()
+
+
 def test_help_command_is_available_while_pending(qtbot, monkeypatch):
     assistant = build_assistant(qtbot, monkeypatch)
     assistant.awaiting_tool_result = True
@@ -114,6 +124,29 @@ def test_help_command_is_available_while_pending(qtbot, monkeypatch):
     assert "Assistant commands:" in assistant.editorOutput.toPlainText()
 
 
+def test_status_command_reports_no_pending_state(qtbot, monkeypatch):
+    assistant = build_assistant(qtbot, monkeypatch)
+
+    assistant.commandEditor.setText("/status")
+    assistant.runCommand()
+
+    assert "No pending beacon command result." in assistant.editorOutput.toPlainText()
+
+
+def test_status_command_reports_pending_context(qtbot, monkeypatch):
+    assistant = build_assistant(qtbot, monkeypatch)
+    assistant._process_assistant_response(pending_message())
+
+    assistant.commandEditor.setText("/status")
+    assistant.runCommand()
+
+    output = assistant.editorOutput.toPlainText()
+    assert "Pending command: run touch /tmp/hello" in output
+    assert "Command ID: cmd-1" in output
+    assert "Beacon: beacon-12345678" in output
+    assert "Listener: listener-1" in output
+
+
 def test_console_receive_resumes_matching_pending_command_id(qtbot, monkeypatch):
     assistant = build_assistant(qtbot, monkeypatch)
     resume_calls = []
@@ -140,7 +173,13 @@ def test_console_receive_resumes_matching_pending_command_id(qtbot, monkeypatch)
         "cmd-1",
     )
 
-    assert resume_calls == [("pending-1", "[no output]")]
+    assert len(resume_calls) == 1
+    assert resume_calls[0][0] == "pending-1"
+    assert "command_id: cmd-1" in resume_calls[0][1]
+    assert "beacon_hash: beacon-1" in resume_calls[0][1]
+    assert "listener_hash: listener-1" in resume_calls[0][1]
+    assert "command: run touch /tmp/hello" in resume_calls[0][1]
+    assert "[no output]" in resume_calls[0][1]
     assert assistant.awaiting_tool_result is False
     assert assistant.pending_tool_id is None
     assert assistant.pending_tool_context is None
@@ -195,6 +234,8 @@ def test_pending_response_starts_timeout_timer(qtbot, monkeypatch):
     assert assistant.pending_tool_context["command_id"] == "cmd-1"
     assert assistant.pending_tool_context["command_line"] == "run touch /tmp/hello"
     assert assistant.pending_tool_timer.isActive() is True
+    assert "Waiting for beacon command result." in assistant.editorOutput.toPlainText()
+    assert "Command ID: cmd-1" in assistant.editorOutput.toPlainText()
 
 
 def test_pending_timeout_clears_state_and_reports(qtbot, monkeypatch):