strix-agent 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

strix/tools/terminal/terminal_manager.py

@@ -5,173 +5,133 @@ import sys
 import threading
 from typing import Any
 
-from .terminal_instance import TerminalInstance
+from .terminal_session import TerminalSession
 
 
 class TerminalManager:
     def __init__(self) -> None:
-        self.terminals: dict[str, TerminalInstance] = {}
+        self.sessions: dict[str, TerminalSession] = {}
         self._lock = threading.Lock()
         self.default_terminal_id = "default"
+        self.default_timeout = 30.0
 
         self._register_cleanup_handlers()
 
-    def create_terminal(
-        self, terminal_id: str | None = None, inputs: list[str] | None = None
+    def execute_command(
+        self,
+        command: str,
+        is_input: bool = False,
+        timeout: float | None = None,
+        terminal_id: str | None = None,
+        no_enter: bool = False,
     ) -> dict[str, Any]:
         if terminal_id is None:
             terminal_id = self.default_terminal_id
 
-        with self._lock:
-            if terminal_id in self.terminals:
-                raise ValueError(f"Terminal '{terminal_id}' already exists")
-
-            initial_command = None
-            if inputs:
-                command_parts: list[str] = []
-                for input_item in inputs:
-                    if input_item == "Enter":
-                        initial_command = " ".join(command_parts) + "\n"
-                        break
-                    if input_item.startswith("literal:"):
-                        command_parts.append(input_item[8:])
-                    elif input_item not in [
-                        "Space",
-                        "Tab",
-                        "Backspace",
-                    ]:
-                        command_parts.append(input_item)
-
-            try:
-                terminal = TerminalInstance(terminal_id, initial_command)
-                self.terminals[terminal_id] = terminal
-
-                if inputs and not initial_command:
-                    terminal.send_input(inputs)
-                    result = terminal.wait(2.0)
-                else:
-                    result = terminal.wait(1.0)
-
-                result["message"] = f"Terminal '{terminal_id}' created successfully"
-
-            except (OSError, ValueError, RuntimeError) as e:
-                raise RuntimeError(f"Failed to create terminal '{terminal_id}': {e}") from e
-            else:
-                return result
-
-    def send_input(
-        self, terminal_id: str | None = None, inputs: list[str] | None = None
-    ) -> dict[str, Any]:
-        if terminal_id is None:
-            terminal_id = self.default_terminal_id
-
-        if not inputs:
-            raise ValueError("No inputs provided")
-
-        with self._lock:
-            if terminal_id not in self.terminals:
-                raise ValueError(f"Terminal '{terminal_id}' not found")
-
-            terminal = self.terminals[terminal_id]
+        session = self._get_or_create_session(terminal_id)
 
         try:
-            terminal.send_input(inputs)
-            result = terminal.wait(2.0)
-            result["message"] = f"Input sent to terminal '{terminal_id}'"
-        except (OSError, ValueError, RuntimeError) as e:
-            raise RuntimeError(f"Failed to send input to terminal '{terminal_id}': {e}") from e
-        else:
-            return result
+            result = session.execute(command, is_input, timeout or self.default_timeout, no_enter)
 
-    def wait_terminal(
-        self, terminal_id: str | None = None, duration: float = 1.0
-    ) -> dict[str, Any]:
-        if terminal_id is None:
-            terminal_id = self.default_terminal_id
-
-        with self._lock:
-            if terminal_id not in self.terminals:
-                raise ValueError(f"Terminal '{terminal_id}' not found")
+            return {
+                "content": result["content"],
+                "command": command,
+                "terminal_id": terminal_id,
+                "status": result["status"],
+                "exit_code": result.get("exit_code"),
+                "working_dir": result.get("working_dir"),
+            }
 
-            terminal = self.terminals[terminal_id]
+        except RuntimeError as e:
+            return {
+                "error": str(e),
+                "command": command,
+                "terminal_id": terminal_id,
+                "content": "",
+                "status": "error",
+                "exit_code": None,
+                "working_dir": None,
+            }
+        except OSError as e:
+            return {
+                "error": f"System error: {e}",
+                "command": command,
+                "terminal_id": terminal_id,
+                "content": "",
+                "status": "error",
+                "exit_code": None,
+                "working_dir": None,
+            }
 
-        try:
-            result = terminal.wait(duration)
-            result["message"] = f"Waited {duration}s on terminal '{terminal_id}'"
-        except (OSError, ValueError, RuntimeError) as e:
-            raise RuntimeError(f"Failed to wait on terminal '{terminal_id}': {e}") from e
-        else:
-            return result
+    def _get_or_create_session(self, terminal_id: str) -> TerminalSession:
+        with self._lock:
+            if terminal_id not in self.sessions:
+                self.sessions[terminal_id] = TerminalSession(terminal_id)
+            return self.sessions[terminal_id]
 
-    def close_terminal(self, terminal_id: str | None = None) -> dict[str, Any]:
+    def close_session(self, terminal_id: str | None = None) -> dict[str, Any]:
         if terminal_id is None:
             terminal_id = self.default_terminal_id
 
         with self._lock:
-            if terminal_id not in self.terminals:
-                raise ValueError(f"Terminal '{terminal_id}' not found")
+            if terminal_id not in self.sessions:
+                return {
+                    "terminal_id": terminal_id,
+                    "message": f"Terminal '{terminal_id}' not found",
+                    "status": "not_found",
+                }
 
-            terminal = self.terminals.pop(terminal_id)
+            session = self.sessions.pop(terminal_id)
 
         try:
-            terminal.close()
-        except (OSError, ValueError, RuntimeError) as e:
-            raise RuntimeError(f"Failed to close terminal '{terminal_id}': {e}") from e
+            session.close()
+        except (RuntimeError, OSError) as e:
+            return {
+                "terminal_id": terminal_id,
+                "error": f"Failed to close terminal '{terminal_id}': {e}",
+                "status": "error",
+            }
         else:
             return {
                 "terminal_id": terminal_id,
                 "message": f"Terminal '{terminal_id}' closed successfully",
-                "snapshot": "",
-                "is_running": False,
+                "status": "closed",
             }
 
-    def get_terminal_snapshot(self, terminal_id: str | None = None) -> dict[str, Any]:
-        if terminal_id is None:
-            terminal_id = self.default_terminal_id
-
-        with self._lock:
-            if terminal_id not in self.terminals:
-                raise ValueError(f"Terminal '{terminal_id}' not found")
-
-            terminal = self.terminals[terminal_id]
-
-        return terminal.get_snapshot()
-
-    def list_terminals(self) -> dict[str, Any]:
+    def list_sessions(self) -> dict[str, Any]:
         with self._lock:
-            terminal_info = {}
-            for tid, terminal in self.terminals.items():
-                terminal_info[tid] = {
-                    "is_running": terminal.is_running,
-                    "is_alive": terminal.is_alive(),
-                    "process_id": terminal.process.pid if terminal.process else None,
+            session_info: dict[str, dict[str, Any]] = {}
+            for tid, session in self.sessions.items():
+                session_info[tid] = {
+                    "is_running": session.is_running(),
+                    "working_dir": session.get_working_dir(),
                 }
 
-        return {"terminals": terminal_info, "total_count": len(terminal_info)}
+        return {"sessions": session_info, "total_count": len(session_info)}
 
-    def cleanup_dead_terminals(self) -> None:
+    def cleanup_dead_sessions(self) -> None:
         with self._lock:
-            dead_terminals = []
-            for tid, terminal in self.terminals.items():
-                if not terminal.is_alive():
-                    dead_terminals.append(tid)
+            dead_sessions: list[str] = []
+            for tid, session in self.sessions.items():
+                if not session.is_running():
+                    dead_sessions.append(tid)
 
-            for tid in dead_terminals:
-                terminal = self.terminals.pop(tid)
+            for tid in dead_sessions:
+                session = self.sessions.pop(tid)
                 with contextlib.suppress(Exception):
-                    terminal.close()
+                    session.close()
 
-    def close_all_terminals(self) -> None:
+    def close_all_sessions(self) -> None:
         with self._lock:
-            terminals_to_close = list(self.terminals.values())
-            self.terminals.clear()
+            sessions_to_close = list(self.sessions.values())
+            self.sessions.clear()
 
-        for terminal in terminals_to_close:
+        for session in sessions_to_close:
             with contextlib.suppress(Exception):
-                terminal.close()
+                session.close()
 
     def _register_cleanup_handlers(self) -> None:
-        atexit.register(self.close_all_terminals)
+        atexit.register(self.close_all_sessions)
 
         signal.signal(signal.SIGTERM, self._signal_handler)
         signal.signal(signal.SIGINT, self._signal_handler)
@@ -180,7 +140,7 @@ class TerminalManager:
             signal.signal(signal.SIGHUP, self._signal_handler)
 
     def _signal_handler(self, _signum: int, _frame: Any) -> None:
-        self.close_all_terminals()
+        self.close_all_sessions()
         sys.exit(0)