kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/tests/services/test_sandbox_terminal_input.py

@@ -0,0 +1,98 @@
+import asyncio
+from types import SimpleNamespace
+
+import pytest
+
+from kolega_code.sandbox.terminal import SandboxTerminalManager
+
+
+class FakeCommandHandle:
+    def __init__(self, pid: int = 123):
+        self.pid = pid
+        self._done = asyncio.Event()
+
+    async def wait(self):
+        await self._done.wait()
+        return SimpleNamespace(exit_code=0)
+
+    def complete(self) -> None:
+        self._done.set()
+
+
+class FakeCommands:
+    def __init__(self):
+        self.handle = FakeCommandHandle()
+        self.run_calls = []
+        self.send_stdin_calls = []
+        self.started = asyncio.Event()
+
+    async def run(self, command: str, **kwargs):
+        if command.startswith("test -d"):
+            return SimpleNamespace(exit_code=0)
+
+        self.run_calls.append((command, kwargs))
+        self.started.set()
+        return self.handle
+
+    async def send_stdin(self, pid: int, data: str):
+        self.send_stdin_calls.append((pid, data))
+
+
+class FakeSandbox:
+    def __init__(self):
+        self.commands = FakeCommands()
+
+
+@pytest.mark.asyncio
+async def test_sandbox_terminal_input_uses_active_command_stdin():
+    sandbox = FakeSandbox()
+    manager = SandboxTerminalManager(sandbox, "workspace", "thread")
+    terminal_id = await manager.launch_terminal()
+
+    command_id = await manager.send_command_tracked(terminal_id, "python prompt.py", "Prompt test")
+    await asyncio.wait_for(sandbox.commands.started.wait(), timeout=1)
+
+    assert sandbox.commands.run_calls
+    _, kwargs = sandbox.commands.run_calls[0]
+    assert kwargs["background"] is True
+    assert kwargs["stdin"] is True
+    assert manager.command_history[command_id]["pid"] == 123
+
+    result = await manager.send_input(terminal_id, "Ada")
+
+    assert result is True
+    assert sandbox.commands.send_stdin_calls == [(123, "Ada\n")]
+    assert "Ada" not in manager.read_output(terminal_id, num_chars=1000)
+
+    sandbox.commands.handle.complete()
+    for _ in range(10):
+        if manager.get_command_status(terminal_id, command_id)["status"] == "completed":
+            break
+        await asyncio.sleep(0.01)
+
+    assert manager.get_command_status(terminal_id, command_id)["status"] == "completed"
+
+
+@pytest.mark.asyncio
+async def test_sandbox_terminal_input_requires_command_id_when_ambiguous():
+    manager = SandboxTerminalManager(FakeSandbox(), "workspace", "thread")
+    terminal_id = await manager.launch_terminal()
+    first_command = {
+        "command": "python prompt_one.py",
+        "terminal_id": terminal_id,
+        "status": "running",
+        "pid": 101,
+    }
+    second_command = {
+        "command": "python prompt_two.py",
+        "terminal_id": terminal_id,
+        "status": "running",
+        "pid": 102,
+    }
+    manager.command_history["cmd_1"] = first_command
+    manager.command_history["cmd_2"] = second_command
+    manager.terminals[terminal_id]["active_commands"]["cmd_1"] = first_command
+    manager.terminals[terminal_id]["active_commands"]["cmd_2"] = second_command
+
+    with pytest.raises(ValueError, match="Multiple active commands"):
+        await manager.send_input(terminal_id, "Ada")

kolega_code/agent/tests/services/test_terminal.py

@@ -0,0 +1,154 @@
+import asyncio
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+
+from kolega_code.services.terminal import AsyncPersistentTerminal, LocalTerminalManager
+
+
+class TestAsyncPersistentTerminal:
+    """Test class for AsyncPersistentTerminal read_output with offset functionality."""
+
+    def test_read_output_with_offset(self):
+        """Test read_output method with offset parameter."""
+        terminal = AsyncPersistentTerminal(
+            workspace_id="test_workspace",
+            thread_id="test_thread",
+            terminal_id="test_terminal",
+            connection_manager=Mock(),
+            auto_activate_venv=False,
+        )
+
+        # Create test output
+        test_output = "0123456789ABCDEFGHIJ"  # 20 characters
+        terminal.persistent_output_buffer = bytearray(test_output.encode())
+
+        # Test default behavior (offset = 0)
+        result = terminal.read_output(num_chars=5, offset=0)
+        assert result == "FGHIJ"  # Last 5 characters
+
+        # Test with offset = 3 (skip last 3 characters, read 5 before that)
+        result = terminal.read_output(num_chars=5, offset=3)
+        assert result == "CDEFG"  # Characters at indices 12-16 (skipping last 3: HIJ)
+
+        # Test with offset = 10 (skip last 10 characters, read 5 before that)
+        result = terminal.read_output(num_chars=5, offset=10)
+        assert result == "56789"  # Characters at indices 5-9
+
+        # Test edge case: offset + num_chars > total length
+        result = terminal.read_output(num_chars=15, offset=5)
+        assert result == "0123456789ABCDE"  # Should read from start to (total - offset)
+
+        # Test edge case: offset >= total length
+        result = terminal.read_output(num_chars=5, offset=25)
+        assert result == ""  # Should return empty string
+
+        # Test when trying to read more than available
+        result = terminal.read_output(num_chars=10, offset=5)
+        assert result == "56789ABCDE"  # Characters at indices 5-14 (skipping last 5: FGHIJ)
+
+        # Test with empty buffer
+        terminal.persistent_output_buffer = bytearray()
+        result = terminal.read_output(num_chars=5, offset=3)
+        assert result == ""
+
+    def test_read_output_with_unicode_and_offset(self):
+        """Test read_output method with offset parameter and unicode characters."""
+        terminal = AsyncPersistentTerminal(
+            workspace_id="test_workspace",
+            thread_id="test_thread",
+            terminal_id="test_terminal",
+            connection_manager=Mock(),
+            auto_activate_venv=False,
+        )
+
+        # Create test output with unicode characters
+        test_output = "Hello 🌍 World 🚀 Test"  # Mix of ASCII and unicode
+        terminal.persistent_output_buffer = bytearray(test_output.encode())
+
+        # Test reading with offset (should handle unicode properly)
+        result = terminal.read_output(num_chars=10, offset=5)
+        expected_total_chars = len(test_output)
+        expected_start = max(0, expected_total_chars - 5 - 10)
+        expected_end = max(0, expected_total_chars - 5)
+        expected = test_output[expected_start:expected_end]
+        assert result == expected
+
+    @pytest.mark.asyncio
+    async def test_send_input_appends_newline_without_mutating_last_command(self):
+        terminal = AsyncPersistentTerminal(
+            workspace_id="test_workspace",
+            thread_id="test_thread",
+            terminal_id="test_terminal",
+            connection_manager=Mock(),
+            auto_activate_venv=False,
+        )
+        terminal.is_running = True
+        terminal.master_fd = 123
+        terminal.last_command = "python prompt.py\n"
+        terminal.last_command_purpose = "Prompt test"
+
+        with patch("kolega_code.services.terminal.os.write") as mock_write:
+            result = await terminal.send_input("Ada", submit=True)
+
+        assert result is True
+        mock_write.assert_called_once_with(123, b"Ada\n")
+        assert terminal.last_command == "python prompt.py\n"
+        assert terminal.last_command_purpose == "Prompt test"
+
+    @pytest.mark.asyncio
+    async def test_send_input_can_send_raw_text(self):
+        terminal = AsyncPersistentTerminal(
+            workspace_id="test_workspace",
+            thread_id="test_thread",
+            terminal_id="test_terminal",
+            connection_manager=Mock(),
+            auto_activate_venv=False,
+        )
+        terminal.is_running = True
+        terminal.master_fd = 123
+
+        with patch("kolega_code.services.terminal.os.write") as mock_write:
+            result = await terminal.send_input("A", submit=False)
+
+        assert result is True
+        mock_write.assert_called_once_with(123, b"A")
+
+
+@pytest.mark.asyncio
+async def test_local_terminal_manager_can_answer_python_prompt(tmp_path):
+    manager = LocalTerminalManager("test_workspace", "test_thread", AsyncMock())
+    terminal_id = await manager.launch_terminal(cwd=tmp_path, auto_activate_venv=False)
+    command_id = None
+
+    try:
+        command_id = await manager.send_command_tracked(
+            terminal_id,
+            'python -c "prompt = \'READY_\' + \'FOR_\' + \'INPUT>\'; name = input(prompt); print(\'hello \' + name)"',
+            "Prompt for a name and echo it",
+        )
+        assert command_id
+
+        prompt_seen = False
+        for _ in range(50):
+            if "READY_FOR_INPUT>" in manager.read_output(terminal_id, num_chars=500):
+                prompt_seen = True
+                break
+            await asyncio.sleep(0.1)
+
+        assert prompt_seen
+        assert await manager.send_input(terminal_id, "Ada", command_id=command_id)
+
+        completed = False
+        for _ in range(50):
+            status = manager.get_command_status(terminal_id, command_id)
+            if status["status"] == "completed":
+                completed = True
+                break
+            await asyncio.sleep(0.1)
+
+        assert completed
+        assert "hello Ada" in manager.read_output(terminal_id, num_chars=1000)
+    finally:
+        if terminal_id in manager.terminals:
+            await manager.close_terminal(terminal_id)

kolega_code/agent/tests/services/test_terminal_command_tracking.py

@@ -0,0 +1,385 @@
+import os
+import time
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+import psutil
+
+from kolega_code.services.terminal import AsyncPersistentTerminal, LocalTerminalManager
+
+
+# Check if running in CI environment
+SKIP_IN_CI = bool(os.getenv("CI")) or bool(os.getenv("GITLAB_CI"))
+
+
+@pytest.fixture
+def mock_connection_manager():
+    return AsyncMock()
+
+
+@pytest.fixture
+def workspace_id():
+    return "test_workspace"
+
+
+@pytest.fixture
+def terminal_id():
+    return "test_terminal"
+
+
+class TestAsyncPersistentTerminalCommandTracking:
+    """Tests for command tracking in AsyncPersistentTerminal"""
+
+    @pytest.fixture
+    def mock_terminal(self, workspace_id, terminal_id, mock_connection_manager):
+        """Create a mock terminal without actually starting it"""
+        with patch("kolega_code.services.terminal.pty.fork"), patch(
+            "kolega_code.services.terminal.os.execvpe"
+        ), patch("kolega_code.services.terminal.fcntl.fcntl"):
+            # Don't patch asyncio.create_task here - let each test handle it
+
+            terminal = AsyncPersistentTerminal(
+                workspace_id=workspace_id,
+                thread_id="test_thread",
+                terminal_id=terminal_id,
+                connection_manager=mock_connection_manager,
+                cwd="/tmp",
+                auto_activate_venv=False,
+            )
+
+            # Mock the required attributes for testing
+            terminal.is_running = True
+            terminal.master_fd = 123
+            terminal.pid = 12345
+            terminal.shell_cleaned = True
+
+            return terminal
+
+    def test_command_tracking_initialization(self, mock_terminal):
+        """Test that command tracking attributes are initialized correctly"""
+        assert mock_terminal.active_commands == {}
+        assert mock_terminal.command_counter == 0
+        assert mock_terminal.shell_prompt_detected
+
+    @pytest.mark.asyncio
+    async def test_send_command_tracked_success(self, mock_terminal):
+        """Test successful command tracking"""
+        # Mock the send_command method
+        mock_terminal.send_command = AsyncMock(return_value=True)
+
+        # Mock the monitoring task creation with a function that properly handles the coroutine
+        def mock_create_task(coro):
+            # Close the coroutine to avoid warnings
+            if hasattr(coro, "close"):
+                coro.close()
+            return Mock()
+
+        with patch("asyncio.create_task", side_effect=mock_create_task) as mock_create_task_patch:
+            command_id = await mock_terminal.send_command_tracked("echo test", "Test purpose")
+
+            assert command_id == "test_terminal_1"
+            assert "test_terminal_1" in mock_terminal.active_commands
+
+            command_info = mock_terminal.active_commands["test_terminal_1"]
+            assert command_info["command"] == "echo test"
+            assert command_info["purpose"] == "Test purpose"
+            assert command_info["status"] == "running"
+            assert command_info["child_pids"] == set()
+            assert command_info["return_code"] is None
+            assert isinstance(command_info["start_time"], float)
+
+            # Verify monitoring task was created
+            assert mock_create_task_patch.call_count == 1
+            assert not mock_terminal.shell_prompt_detected
+
+    @pytest.mark.asyncio
+    async def test_send_command_tracked_failure(self, mock_terminal):
+        """Test command tracking when send fails"""
+        # Mock the send_command method to fail
+        mock_terminal.send_command = AsyncMock(return_value=False)
+
+        command_id = await mock_terminal.send_command_tracked("echo test", "Test purpose")
+
+        assert command_id is None
+        assert len(mock_terminal.active_commands) == 0
+
+    @pytest.mark.asyncio
+    async def test_send_command_tracked_terminal_not_running(self, mock_terminal):
+        """Test command tracking when terminal is not running"""
+        mock_terminal.is_running = False
+
+        command_id = await mock_terminal.send_command_tracked("echo test", "Test purpose")
+
+        assert command_id is None
+        assert len(mock_terminal.active_commands) == 0
+
+    def test_get_command_status_running(self, mock_terminal):
+        """Test getting status of a running command"""
+        # Add a test command
+        start_time = time.time()
+        mock_terminal.active_commands["test_cmd"] = {
+            "command": "sleep 10",
+            "purpose": "Test sleep",
+            "start_time": start_time,
+            "status": "running",
+            "child_pids": {1234, 5678},
+            "return_code": None,
+        }
+
+        status = mock_terminal.get_command_status("test_cmd")
+
+        assert status["status"] == "running"
+        assert status["command"] == "sleep 10"
+        assert status["purpose"] == "Test sleep"
+        assert status["duration"] >= 0
+        assert status["return_code"] is None
+        assert set(status["child_pids"]) == {1234, 5678}
+
+    def test_get_command_status_not_found(self, mock_terminal):
+        """Test getting status of non-existent command"""
+        status = mock_terminal.get_command_status("nonexistent")
+
+        assert status["status"] == "not_found"
+
+    def test_get_active_commands(self, mock_terminal):
+        """Test getting all active commands"""
+        # Add some test commands
+        mock_terminal.active_commands = {
+            "cmd1": {
+                "command": "running_cmd",
+                "start_time": time.time(),
+                "status": "running",
+                "child_pids": set(),
+                "return_code": None,
+            },
+            "cmd2": {
+                "command": "completed_cmd",
+                "start_time": time.time() - 10,
+                "status": "completed",
+                "child_pids": set(),
+                "return_code": 0,
+            },
+        }
+
+        active = mock_terminal.get_active_commands()
+
+        assert len(active) == 1
+        assert "cmd1" in active
+        assert "cmd2" not in active
+
+    def test_is_ready_for_commands_true(self, mock_terminal):
+        """Test terminal ready state when no active commands"""
+        mock_terminal.shell_prompt_detected = True
+        mock_terminal.active_commands = {}
+
+        assert mock_terminal.is_ready_for_commands()
+
+    def test_is_ready_for_commands_false_no_prompt(self, mock_terminal):
+        """Test terminal not ready when no prompt detected"""
+        mock_terminal.shell_prompt_detected = False
+        mock_terminal.active_commands = {}
+
+        assert not mock_terminal.is_ready_for_commands()
+
+    def test_is_ready_for_commands_false_active_commands(self, mock_terminal):
+        """Test terminal not ready when commands are active"""
+        mock_terminal.shell_prompt_detected = True
+        mock_terminal.active_commands = {
+            "cmd1": {
+                "command": "running_cmd",
+                "status": "running",
+                "start_time": time.time(),
+                "child_pids": set(),
+                "return_code": None,
+            }
+        }
+
+        assert not mock_terminal.is_ready_for_commands()
+
+    def test_check_for_shell_prompt_detected(self, mock_terminal):
+        """Test shell prompt detection"""
+        # Mock read_output to return output with prompt
+        mock_terminal.read_output = Mock(return_value="some output\n$ ")
+
+        assert mock_terminal._check_for_shell_prompt()
+
+    def test_check_for_shell_prompt_not_detected(self, mock_terminal):
+        """Test shell prompt not detected"""
+        # Mock read_output to return output without prompt
+        mock_terminal.read_output = Mock(return_value="some output\nstill processing...")
+
+        assert not mock_terminal._check_for_shell_prompt()
+
+    @pytest.mark.asyncio
+    @pytest.mark.skipif(SKIP_IN_CI, reason="Skipping slow test in CI environment")
+    async def test_monitor_command_completion_success(self, mock_terminal):
+        """Test command completion monitoring"""
+        # Set up a test command
+        command_id = "test_cmd"
+        mock_terminal.active_commands[command_id] = {
+            "command": "echo test",
+            "start_time": time.time(),
+            "status": "running",
+            "child_pids": set(),
+            "return_code": None,
+        }
+
+        # Mock psutil to simulate no child processes
+        with patch("psutil.Process") as mock_process_class:
+            mock_process = Mock()
+            mock_process.children.return_value = []
+            mock_process_class.return_value = mock_process
+
+            # Mock prompt detection to return True
+            mock_terminal._check_for_shell_prompt = Mock(return_value=True)
+
+            # Run the monitoring
+            await mock_terminal._monitor_command_completion(command_id)
+
+            # Check that command was marked as completed
+            assert mock_terminal.active_commands[command_id]["status"] == "completed"
+            assert mock_terminal.active_commands[command_id]["return_code"] == 0
+            assert mock_terminal.shell_prompt_detected
+
+    @pytest.mark.asyncio
+    @pytest.mark.skipif(SKIP_IN_CI, reason="Skipping slow test in CI environment")
+    async def test_monitor_command_completion_process_died(self, mock_terminal):
+        """Test command completion monitoring when shell process dies"""
+        command_id = "test_cmd"
+        mock_terminal.active_commands[command_id] = {
+            "command": "echo test",
+            "start_time": time.time(),
+            "status": "running",
+            "child_pids": set(),
+            "return_code": None,
+        }
+
+        # Mock psutil to raise NoSuchProcess
+        with patch("psutil.Process", side_effect=psutil.NoSuchProcess(123)):
+            await mock_terminal._monitor_command_completion(command_id)
+
+            # Check that command was marked as terminated
+            assert mock_terminal.active_commands[command_id]["status"] == "terminated"
+            assert mock_terminal.active_commands[command_id]["return_code"] == -1
+
+    @pytest.mark.asyncio
+    async def test_monitor_command_completion_monitor_timeout(self, mock_terminal):
+        """Test command monitoring timeout is not reported as completion."""
+        command_id = "test_cmd"
+        mock_terminal.active_commands[command_id] = {
+            "command": "sleep 999",
+            "start_time": time.time(),
+            "status": "running",
+            "child_pids": set(),
+            "return_code": None,
+        }
+
+        with patch.object(AsyncPersistentTerminal, "COMMAND_MONITOR_TIMEOUT_SECONDS", 0):
+            await mock_terminal._monitor_command_completion(command_id)
+
+        command_info = mock_terminal.active_commands[command_id]
+        assert command_info["status"] == "monitor_timeout"
+        assert command_info["return_code"] is None
+        assert command_info["monitor_timeout_seconds"] == 0
+        assert command_id in mock_terminal.get_active_commands()
+
+
+class TestLocalTerminalManagerCommandTracking:
+    """Tests for command tracking in LocalTerminalManager"""
+
+    @pytest.fixture
+    def terminal_manager(self, workspace_id, mock_connection_manager):
+        return LocalTerminalManager(workspace_id, "test-thread-id", mock_connection_manager)
+
+    @pytest.fixture
+    def mock_terminal(self):
+        terminal = Mock()
+        terminal.send_command_tracked = AsyncMock(return_value="terminal_1_1")
+        terminal.get_command_status = Mock(return_value={"status": "running"})
+        terminal.is_alive = AsyncMock(return_value=True)
+        terminal.is_ready_for_commands = Mock(return_value=True)
+        terminal.get_active_commands = Mock(return_value={})
+        terminal.last_command = "echo test"
+        return terminal
+
+    @pytest.mark.asyncio
+    async def test_send_command_tracked_success(self, terminal_manager, mock_terminal):
+        """Test sending tracked command through manager"""
+        terminal_manager.terminals["terminal_1"] = mock_terminal
+
+        command_id = await terminal_manager.send_command_tracked("terminal_1", "echo test", "Test purpose")
+
+        assert command_id == "terminal_1_1"
+        mock_terminal.send_command_tracked.assert_called_once_with("echo test", "Test purpose")
+
+    @pytest.mark.asyncio
+    async def test_send_command_tracked_terminal_not_found(self, terminal_manager):
+        """Test sending tracked command to non-existent terminal"""
+        with pytest.raises(KeyError, match="Terminal with ID invalid not found"):
+            await terminal_manager.send_command_tracked("invalid", "echo test", "Test purpose")
+
+    @pytest.mark.asyncio
+    async def test_send_input_success(self, terminal_manager, mock_terminal):
+        """Test sending input through manager to an active command."""
+        mock_terminal.get_active_commands = Mock(return_value={"cmd_1": {"status": "running"}})
+        mock_terminal.get_command_status = Mock(return_value={"status": "running"})
+        mock_terminal.send_input = AsyncMock(return_value=True)
+        terminal_manager.terminals["terminal_1"] = mock_terminal
+
+        result = await terminal_manager.send_input("terminal_1", "Ada", submit=True, command_id="cmd_1")
+
+        assert result is True
+        mock_terminal.get_command_status.assert_called_once_with("cmd_1")
+        mock_terminal.send_input.assert_awaited_once_with("Ada", submit=True)
+
+    @pytest.mark.asyncio
+    async def test_send_input_requires_active_command(self, terminal_manager, mock_terminal):
+        """Test sending input without an active command is rejected."""
+        mock_terminal.get_active_commands = Mock(return_value={})
+        terminal_manager.terminals["terminal_1"] = mock_terminal
+
+        with pytest.raises(ValueError, match="No active command is running"):
+            await terminal_manager.send_input("terminal_1", "Ada")
+
+    @pytest.mark.asyncio
+    async def test_send_input_requires_command_id_when_ambiguous(self, terminal_manager, mock_terminal):
+        """Test sending input with multiple active commands requires command_id."""
+        mock_terminal.get_active_commands = Mock(
+            return_value={"cmd_1": {"status": "running"}, "cmd_2": {"status": "running"}}
+        )
+        terminal_manager.terminals["terminal_1"] = mock_terminal
+
+        with pytest.raises(ValueError, match="Multiple active commands"):
+            await terminal_manager.send_input("terminal_1", "Ada")
+
+    def test_get_command_status_success(self, terminal_manager, mock_terminal):
+        """Test getting command status through manager"""
+        terminal_manager.terminals["terminal_1"] = mock_terminal
+
+        status = terminal_manager.get_command_status("terminal_1", "cmd_1")
+
+        assert status["status"] == "running"
+        mock_terminal.get_command_status.assert_called_once_with("cmd_1")
+
+    def test_get_command_status_terminal_not_found(self, terminal_manager):
+        """Test getting command status from non-existent terminal"""
+        with pytest.raises(KeyError, match="Terminal with ID invalid not found"):
+            terminal_manager.get_command_status("invalid", "cmd_1")
+
+    @pytest.mark.asyncio
+    async def test_get_terminal_status_success(self, terminal_manager, mock_terminal):
+        """Test getting terminal status through manager"""
+        terminal_manager.terminals["terminal_1"] = mock_terminal
+
+        status = await terminal_manager.get_terminal_status("terminal_1")
+
+        assert status["running"]
+        assert status["ready_for_commands"]
+        assert status["active_commands"] == {}
+        assert status["last_command"] == "echo test"
+
+    @pytest.mark.asyncio
+    async def test_get_terminal_status_terminal_not_found(self, terminal_manager):
+        """Test getting status from non-existent terminal"""
+        with pytest.raises(KeyError, match="Terminal with ID invalid not found"):
+            await terminal_manager.get_terminal_status("invalid")