indent 0.1.22__tar.gz → 0.1.23__tar.gz

{indent-0.1.22 → indent-0.1.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: indent
-Version: 0.1.22
+Version: 0.1.23
 Summary: Indent is an AI Pair Programmer
 Author-email: Sashank Thupukari <sashank@exponent.run>
 Requires-Python: <3.13,>=3.10

{indent-0.1.22 → indent-0.1.23}/exponent/__init__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.22'
-__version_tuple__ = version_tuple = (0, 1, 22)
+__version__ = version = '0.1.23'
+__version_tuple__ = version_tuple = (0, 1, 23)
 
 __commit_id__ = commit_id = None

{indent-0.1.22 → indent-0.1.23}/exponent/core/remote_execution/cli_rpc_types.py

@@ -304,6 +304,77 @@ class GenerateUploadUrlResponse(msgspec.Struct, tag="generate_upload_url"):
     s3_uri: str
 
 
+# Terminal session management
+class StartTerminalRequest(msgspec.Struct, tag="start_terminal"):
+    """Start a new terminal session with PTY"""
+
+    session_id: str
+    command: list[str] | None = None  # None = default shell, or specific command
+    cols: int = 80
+    rows: int = 24
+    env: dict[str, str] | None = None  # Additional environment variables
+
+
+class StartTerminalResponse(msgspec.Struct, tag="start_terminal"):
+    """Response after starting terminal"""
+
+    session_id: str
+    success: bool
+    error_message: str | None = None
+
+
+# Terminal input (user typing)
+class TerminalInputRequest(msgspec.Struct, tag="terminal_input"):
+    """Send user input to terminal"""
+
+    session_id: str
+    data: str  # Raw input data from user
+
+
+class TerminalInputResponse(msgspec.Struct, tag="terminal_input"):
+    """Acknowledge input received"""
+
+    session_id: str
+    success: bool
+
+
+# Terminal resize
+class TerminalResizeRequest(msgspec.Struct, tag="terminal_resize"):
+    """Resize terminal dimensions"""
+
+    session_id: str
+    cols: int
+    rows: int
+
+
+class TerminalResizeResponse(msgspec.Struct, tag="terminal_resize"):
+    """Acknowledge resize"""
+
+    session_id: str
+    success: bool
+
+
+# Terminal stop
+class StopTerminalRequest(msgspec.Struct, tag="stop_terminal"):
+    """Stop a terminal session"""
+
+    session_id: str
+
+
+class StopTerminalResponse(msgspec.Struct, tag="stop_terminal"):
+    """Acknowledge terminal stopped"""
+
+    session_id: str
+    success: bool
+
+
+class StreamingCodeExecutionRequest(msgspec.Struct, tag="streaming_code_execution"):
+    correlation_id: str
+    language: str  # "python" or "shell"
+    content: str
+    timeout: int
+
+
 class CliRpcRequest(msgspec.Struct):
     request_id: str
     request: (
@@ -315,6 +386,11 @@ class CliRpcRequest(msgspec.Struct):
         | SwitchCLIChatRequest
         | KeepAliveCliChatRequest
         | GenerateUploadUrlRequest
+        | StartTerminalRequest
+        | TerminalInputRequest
+        | TerminalResizeRequest
+        | StopTerminalRequest
+        | StreamingCodeExecutionRequest
     )
 
 
@@ -326,6 +402,40 @@ class ErrorResponse(msgspec.Struct, tag="error"):
     error_message: str
 
 
+class StreamingCodeExecutionResponseChunk(
+    msgspec.Struct, tag="streaming_code_execution_chunk"
+):
+    correlation_id: str
+    content: str
+    truncated: bool = False
+
+    def add(
+        self, new_chunk: "StreamingCodeExecutionResponseChunk"
+    ) -> "StreamingCodeExecutionResponseChunk":
+        """Aggregates content of this and a new chunk."""
+        assert self.correlation_id == new_chunk.correlation_id
+        return StreamingCodeExecutionResponseChunk(
+            correlation_id=self.correlation_id,
+            content=self.content + new_chunk.content,
+            truncated=self.truncated or new_chunk.truncated,
+        )
+
+
+class StreamingCodeExecutionResponse(msgspec.Struct, tag="streaming_code_execution"):
+    correlation_id: str
+    content: str
+    truncated: bool = False
+    # Only present for shell code execution
+    cancelled_for_timeout: bool = False
+    exit_code: int | None = None
+    halted: bool = False
+
+
+class StreamingErrorResponse(msgspec.Struct, tag="streaming_error"):
+    correlation_id: str
+    error_message: str
+
+
 class CliRpcResponse(msgspec.Struct):
     request_id: str
     response: (
@@ -339,4 +449,11 @@ class CliRpcResponse(msgspec.Struct):
         | SwitchCLIChatResponse
         | KeepAliveCliChatResponse
         | GenerateUploadUrlResponse
+        | StartTerminalResponse
+        | TerminalInputResponse
+        | TerminalResizeResponse
+        | StopTerminalResponse
+        | StreamingCodeExecutionResponseChunk
+        | StreamingCodeExecutionResponse
+        | StreamingErrorResponse
     )

{indent-0.1.22 → indent-0.1.23}/exponent/core/remote_execution/client.py

@@ -38,8 +38,16 @@ from exponent.core.remote_execution.cli_rpc_types import (
     HttpRequest,
     KeepAliveCliChatRequest,
     KeepAliveCliChatResponse,
+    StartTerminalRequest,
+    StartTerminalResponse,
+    StopTerminalRequest,
+    StopTerminalResponse,
     SwitchCLIChatRequest,
     SwitchCLIChatResponse,
+    TerminalInputRequest,
+    TerminalInputResponse,
+    TerminalResizeRequest,
+    TerminalResizeResponse,
     TerminateRequest,
     TerminateResponse,
     ToolExecutionRequest,
@@ -56,6 +64,8 @@ from exponent.core.remote_execution.session import (
     get_session,
     send_exception_log,
 )
+from exponent.core.remote_execution.terminal_session import TerminalSessionManager
+from exponent.core.remote_execution.terminal_types import TerminalMessage
 from exponent.core.remote_execution.tool_execution import (
     execute_bash_tool,
     execute_tool,
@@ -66,9 +76,7 @@ from exponent.core.remote_execution.types import (
     CLIConnectedState,
     CreateChatResponse,
     HeartbeatInfo,
-    RemoteExecutionResponseType,
     RunWorkflowRequest,
-    StreamingCodeExecutionRequest,
     WorkflowInput,
     WorkflowTriggerRequest,
     WorkflowTriggerResponse,
@@ -183,11 +191,12 @@ class RemoteExecutionClient:
             # Handle cancellation gracefully
             return None
 
-    async def _handle_websocket_message(
+    async def _handle_websocket_message(  # noqa: PLR0911, PLR0915
         self,
         msg: str,
         websocket: ClientConnection,
         requests: asyncio.Queue[CliRpcRequest],
+        terminal_session_manager: TerminalSessionManager,
     ) -> REMOTE_EXECUTION_CLIENT_EXIT_INFO | None:
         """Handle an incoming websocket message.
         Returns None to continue processing, or a REMOTE_EXECUTION_CLIENT_EXIT_INFO to exit."""
@@ -215,7 +224,7 @@ class RemoteExecutionClient:
         data = json.dumps(msg_data["data"])
         try:
             request = msgspec.json.decode(data, type=CliRpcRequest)
-        except msgspec.DecodeError as e:
+        except (msgspec.DecodeError, msgspec.ValidationError) as e:
             # Try and decode to get request_id if possible
             request = msgspec.json.decode(data)
             if isinstance(request, dict) and "request_id" in request:
@@ -317,6 +326,101 @@ class RemoteExecutionClient:
                 )
             )
             return None
+        elif isinstance(request.request, StartTerminalRequest):
+            # Start a new terminal session
+            session_id = await terminal_session_manager.start_session(
+                websocket=websocket,
+                session_id=request.request.session_id,
+                command=request.request.command,
+                cols=request.request.cols,
+                rows=request.request.rows,
+                env=request.request.env,
+            )
+            await websocket.send(
+                json.dumps(
+                    {
+                        "type": "result",
+                        "data": msgspec.to_builtins(
+                            CliRpcResponse(
+                                request_id=request.request_id,
+                                response=StartTerminalResponse(
+                                    session_id=session_id, success=True
+                                ),
+                            )
+                        ),
+                    }
+                )
+            )
+            return None
+        elif isinstance(request.request, TerminalInputRequest):
+            # Send input to terminal session
+            success = await terminal_session_manager.send_input(
+                session_id=request.request.session_id,
+                data=request.request.data,
+            )
+            await websocket.send(
+                json.dumps(
+                    {
+                        "type": "result",
+                        "data": msgspec.to_builtins(
+                            CliRpcResponse(
+                                request_id=request.request_id,
+                                response=TerminalInputResponse(
+                                    session_id=request.request.session_id,
+                                    success=success,
+                                ),
+                            )
+                        ),
+                    }
+                )
+            )
+            return None
+        elif isinstance(request.request, TerminalResizeRequest):
+            # Resize terminal session
+            success = await terminal_session_manager.resize_terminal(
+                session_id=request.request.session_id,
+                rows=request.request.rows,
+                cols=request.request.cols,
+            )
+            await websocket.send(
+                json.dumps(
+                    {
+                        "type": "result",
+                        "data": msgspec.to_builtins(
+                            CliRpcResponse(
+                                request_id=request.request_id,
+                                response=TerminalResizeResponse(
+                                    session_id=request.request.session_id,
+                                    success=success,
+                                ),
+                            )
+                        ),
+                    }
+                )
+            )
+            return None
+        elif isinstance(request.request, StopTerminalRequest):
+            # Stop terminal session
+            success = await terminal_session_manager.stop_session(
+                session_id=request.request.session_id
+            )
+            await websocket.send(
+                json.dumps(
+                    {
+                        "type": "result",
+                        "data": msgspec.to_builtins(
+                            CliRpcResponse(
+                                request_id=request.request_id,
+                                response=StopTerminalResponse(
+                                    session_id=request.request.session_id,
+                                    success=success,
+                                ),
+                            )
+                        ),
+                    }
+                )
+            )
+            return None
         else:
             if isinstance(request.request, ToolExecutionRequest) and isinstance(
                 request.request.tool_input, BashToolInput
@@ -363,21 +467,31 @@ class RemoteExecutionClient:
                     request = await requests.get()
 
                 try:
-                    # if isinstance(request, StreamingCodeExecutionRequest):
-                    #     async for streaming_response in self.handle_streaming_request(
-                    #         request
-                    #     ):
-                    #         async with results_lock:
-                    #             await results.put(streaming_response)
-                    # else:
-                    # Note that we don't want to hold the lock here
-                    # because we want other executors to be able to
-                    # grab requests while we're handling a request.
-                    logger.info(f"Handling request {request}")
-                    response = await self.handle_request(request)
-                    async with results_lock:
-                        logger.info(f"Putting response {response}")
-                        await results.put(response)
+                    # Check if this is a streaming request
+                    from exponent.core.remote_execution.cli_rpc_types import (
+                        StreamingCodeExecutionRequest,
+                    )
+
+                    if isinstance(request.request, StreamingCodeExecutionRequest):
+                        async for streaming_response in self.handle_streaming_request(
+                            request.request
+                        ):
+                            async with results_lock:
+                                await results.put(
+                                    CliRpcResponse(
+                                        request_id=request.request_id,
+                                        response=streaming_response,
+                                    )
+                                )
+                    else:
+                        # Note that we don't want to hold the lock here
+                        # because we want other executors to be able to
+                        # grab requests while we're handling a request.
+                        logger.info(f"Handling request {request}")
+                        response = await self.handle_request(request)
+                        async with results_lock:
+                            logger.info(f"Putting response {response}")
+                            await results.put(response)
                 except Exception as e:
                     logger.info(f"Error handling request {request}:\n\n{e}")
                     try:
@@ -385,15 +499,32 @@ class RemoteExecutionClient:
                     except Exception:
                         pass
                     async with results_lock:
-                        await results.put(
-                            CliRpcResponse(
-                                request_id=request.request_id,
-                                response=ErrorResponse(
-                                    error_message=str(e),
-                                ),
-                            )
+                        from exponent.core.remote_execution.cli_rpc_types import (
+                            StreamingCodeExecutionRequest,
+                            StreamingErrorResponse,
                         )
 
+                        if isinstance(request.request, StreamingCodeExecutionRequest):
+                            # For streaming requests, send a streaming error response
+                            await results.put(
+                                CliRpcResponse(
+                                    request_id=request.request_id,
+                                    response=StreamingErrorResponse(
+                                        correlation_id=request.request.correlation_id,
+                                        error_message=str(e),
+                                    ),
+                                )
+                            )
+                        else:
+                            await results.put(
+                                CliRpcResponse(
+                                    request_id=request.request_id,
+                                    response=ErrorResponse(
+                                        error_message=str(e),
+                                    ),
+                                )
+                            )
+
         beat_task = asyncio.create_task(beat())
         # Three parallel executors to handle requests
 
@@ -411,6 +542,8 @@ class RemoteExecutionClient:
         beats: asyncio.Queue[HeartbeatInfo],
         requests: asyncio.Queue[CliRpcRequest],
         results: asyncio.Queue[CliRpcResponse],
+        terminal_output_queue: asyncio.Queue[TerminalMessage],
+        terminal_session_manager: TerminalSessionManager,
     ) -> REMOTE_EXECUTION_CLIENT_EXIT_INFO:
         """Process messages from the websocket connection."""
         pending: set[asyncio.Task[object]] = set()
@@ -418,7 +551,8 @@ class RemoteExecutionClient:
             recv = asyncio.create_task(websocket.recv())
             get_beat = asyncio.create_task(beats.get())
             get_result = asyncio.create_task(results.get())
-            pending = {recv, get_beat, get_result}
+            get_terminal_output = asyncio.create_task(terminal_output_queue.get())
+            pending = {recv, get_beat, get_result, get_terminal_output}
 
             while True:
                 done, pending = await asyncio.wait(
@@ -428,7 +562,7 @@ class RemoteExecutionClient:
                 if recv in done:
                     msg = str(recv.result())
                     exit_info = await self._handle_websocket_message(
-                        msg, websocket, requests
+                        msg, websocket, requests, terminal_session_manager
                     )
                     if exit_info is not None:
                         return exit_info
@@ -447,12 +581,24 @@ class RemoteExecutionClient:
 
                 if get_result in done:
                     response = get_result.result()
+                    # All responses are now CliRpcResponse with msgspec
                     data = msgspec.to_builtins(response)
                     msg = json.dumps({"type": "result", "data": data})
                     await websocket.send(msg)
 
                     get_result = asyncio.create_task(results.get())
                     pending.add(get_result)
+
+                if get_terminal_output in done:
+                    terminal_message = get_terminal_output.result()
+                    data = msgspec.to_builtins(terminal_message)
+                    msg = json.dumps({"type": "terminal_message", "data": data})
+                    await websocket.send(msg)
+
+                    get_terminal_output = asyncio.create_task(
+                        terminal_output_queue.get()
+                    )
+                    pending.add(get_terminal_output)
         finally:
             for task in pending:
                 task.cancel()
@@ -466,6 +612,8 @@ class RemoteExecutionClient:
         beats: asyncio.Queue[HeartbeatInfo],
         requests: asyncio.Queue[CliRpcRequest],
         results: asyncio.Queue[CliRpcResponse],
+        terminal_output_queue: asyncio.Queue[TerminalMessage],
+        terminal_session_manager: TerminalSessionManager,
     ) -> REMOTE_EXECUTION_CLIENT_EXIT_INFO | None:
         """Handle a single websocket connection.
         Returns None to continue with reconnection attempts, or an exit info to terminate."""
@@ -476,7 +624,12 @@ class RemoteExecutionClient:
 
         try:
             return await self._process_websocket_messages(
-                websocket, beats, requests, results
+                websocket,
+                beats,
+                requests,
+                results,
+                terminal_output_queue,
+                terminal_session_manager,
             )
         except websockets.exceptions.ConnectionClosed as e:
             if e.rcvd is not None:
@@ -517,6 +670,10 @@ class RemoteExecutionClient:
         beats: asyncio.Queue[HeartbeatInfo] = asyncio.Queue()
         requests: asyncio.Queue[CliRpcRequest] = asyncio.Queue()
         results: asyncio.Queue[CliRpcResponse] = asyncio.Queue()
+        terminal_output_queue: asyncio.Queue[TerminalMessage] = asyncio.Queue()
+
+        # Create terminal session manager ONCE - persist across reconnections
+        terminal_session_manager = TerminalSessionManager(terminal_output_queue)
 
         # Create tasks ONCE - persist across reconnections
         executors = await self._setup_tasks(beats, requests, results)
@@ -529,7 +686,13 @@ class RemoteExecutionClient:
                     [
                         asyncio.create_task(
                             self._handle_websocket_connection(
-                                websocket, connection_tracker, beats, requests, results
+                                websocket,
+                                connection_tracker,
+                                beats,
+                                requests,
+                                results,
+                                terminal_output_queue,
+                                terminal_session_manager,
                             )
                         ),
                         asyncio.create_task(self._timeout_monitor(timeout_seconds)),
@@ -554,6 +717,9 @@ class RemoteExecutionClient:
                 error_message="Could not establish websocket connection"
             )
         finally:
+            # Stop all terminal sessions to clean up PTY processes
+            await terminal_session_manager.stop_all_sessions()
+
             # Cancel all background tasks when exiting
             for task in executors:
                 task.cancel()
@@ -733,6 +899,22 @@ class RemoteExecutionClient:
                 raise ValueError(
                     "KeepAliveCliChatRequest should not be handled by handle_request"
                 )
+            elif isinstance(request.request, StartTerminalRequest):
+                raise ValueError(
+                    "StartTerminalRequest should not be handled by handle_request"
+                )
+            elif isinstance(request.request, TerminalInputRequest):
+                raise ValueError(
+                    "TerminalInputRequest should not be handled by handle_request"
+                )
+            elif isinstance(request.request, TerminalResizeRequest):
+                raise ValueError(
+                    "TerminalResizeRequest should not be handled by handle_request"
+                )
+            elif isinstance(request.request, StopTerminalRequest):
+                raise ValueError(
+                    "StopTerminalRequest should not be handled by handle_request"
+                )
 
             raise ValueError(f"Unhandled request type: {type(request)}")
 
@@ -754,8 +936,13 @@ class RemoteExecutionClient:
                     await self.clear_halt_state(request.request_id)
 
     async def handle_streaming_request(
-        self, request: StreamingCodeExecutionRequest
-    ) -> AsyncGenerator[RemoteExecutionResponseType, None]:
+        self,
+        request: Any,
+    ) -> AsyncGenerator[Any, None]:
+        from exponent.core.remote_execution.cli_rpc_types import (
+            StreamingCodeExecutionRequest,
+        )
+
         if not isinstance(request, StreamingCodeExecutionRequest):
             assert False, f"{type(request)} should be sent to handle_streaming_request"
         async for output in execute_code_streaming(

{indent-0.1.22 → indent-0.1.23}/exponent/core/remote_execution/code_execution.py

@@ -1,5 +1,10 @@
 from collections.abc import AsyncGenerator, Callable
 
+from exponent.core.remote_execution.cli_rpc_types import (
+    StreamingCodeExecutionRequest,
+    StreamingCodeExecutionResponse,
+    StreamingCodeExecutionResponseChunk,
+)
 from exponent.core.remote_execution.languages.python_execution import (
     execute_python_streaming,
 )
@@ -8,13 +13,9 @@ from exponent.core.remote_execution.languages.shell_streaming import (
 )
 from exponent.core.remote_execution.languages.types import StreamedOutputPiece
 from exponent.core.remote_execution.session import RemoteExecutionClientSession
-from exponent.core.remote_execution.types import (
-    StreamingCodeExecutionRequest,
-    StreamingCodeExecutionResponse,
-    StreamingCodeExecutionResponseChunk,
-)
 
 EMPTY_OUTPUT_STRING = "(No output)"
+MAX_OUTPUT_LENGTH = 50000  # Maximum characters to keep in final output
 
 
 async def execute_code_streaming(
@@ -34,9 +35,18 @@ async def execute_code_streaming(
                     content=output.content, correlation_id=request.correlation_id
                 )
             else:
+                final_output = output.output or EMPTY_OUTPUT_STRING
+                truncated = len(final_output) > MAX_OUTPUT_LENGTH
+                if truncated:
+                    final_output = final_output[-MAX_OUTPUT_LENGTH:]
+                    final_output = (
+                        f"[Truncated to last {MAX_OUTPUT_LENGTH} characters]\n\n"
+                        + final_output
+                    )
                 yield StreamingCodeExecutionResponse(
                     correlation_id=request.correlation_id,
-                    content=output.output or EMPTY_OUTPUT_STRING,
+                    content=final_output,
+                    truncated=truncated,
                     halted=output.halted,
                 )
 
@@ -49,9 +59,18 @@ async def execute_code_streaming(
                     content=shell_output.content, correlation_id=request.correlation_id
                 )
             else:
+                final_output = shell_output.output or EMPTY_OUTPUT_STRING
+                truncated = len(final_output) > MAX_OUTPUT_LENGTH
+                if truncated:
+                    final_output = final_output[-MAX_OUTPUT_LENGTH:]
+                    final_output = (
+                        f"[Truncated to last {MAX_OUTPUT_LENGTH} characters]\n\n"
+                        + final_output
+                    )
                 yield StreamingCodeExecutionResponse(
                     correlation_id=request.correlation_id,
-                    content=shell_output.output or EMPTY_OUTPUT_STRING,
+                    content=final_output,
+                    truncated=truncated,
                     halted=shell_output.halted,
                     exit_code=shell_output.exit_code,
                     cancelled_for_timeout=shell_output.cancelled_for_timeout,

{indent-0.1.22 → indent-0.1.23}/exponent/core/remote_execution/languages/shell_streaming.py

@@ -50,7 +50,7 @@ async def read_stream(
 
     while True:
         try:
-            data = await stream.read(4096)
+            data = await stream.read(50_000)
             if not data:
                 break
             chunk = data.decode(encoding=encoding, errors="replace")
@@ -182,10 +182,8 @@ async def execute_shell_streaming(  # noqa: PLR0915
                     piece = await task
                     yield piece
 
-                    if process.returncode is not None:
-                        break
-
                     # Schedule next read from the same stream
+                    # Don't check process.returncode here - we need to drain all buffered output
                     if task is stdout_task and not process.stdout.at_eof():
                         stdout_task = asyncio.create_task(stdout_gen.__anext__())
                         pending.add(stdout_task)

indent-0.1.23/exponent/core/remote_execution/terminal_session.py

@@ -0,0 +1,429 @@
+import asyncio
+import fcntl
+import os
+import pty
+import signal
+import struct
+import sys
+import termios
+import time
+import traceback
+from collections.abc import Callable
+
+import structlog
+
+from exponent.core.remote_execution.terminal_types import (
+    TerminalMessage,
+    TerminalOutput,
+    TerminalResetSessions,
+)
+
+logger = structlog.get_logger(__name__)
+
+
+class TerminalSession:
+    """
+    Manages a PTY session for terminal emulation.
+    Runs on the CLI machine and streams output back to server.
+    """
+
+    def __init__(
+        self,
+        session_id: str,
+        output_callback: Callable[[str], None],
+        cols: int = 80,
+        rows: int = 24,
+    ):
+        self.session_id = session_id
+        self.output_callback = output_callback  # Called with terminal output
+        self.cols = cols
+        self.rows = rows
+        self.master_fd: int | None = None
+        self.pid: int | None = None
+        self._running = False
+        self._read_task: asyncio.Task[None] | None = None
+
+    async def start(
+        self,
+        command: list[str] | None = None,
+        env: dict[str, str] | None = None,
+    ) -> None:
+        """Start the terminal session with PTY"""
+        if self._running:
+            raise RuntimeError(f"Terminal session {self.session_id} already running")
+
+        # Default to bash if no command specified
+        if command is None:
+            command = ["/bin/bash"]
+
+        # Spawn process with PTY
+        try:
+            self.pid, self.master_fd = pty.fork()
+        except OSError as e:
+            logger.error(
+                "Failed to fork PTY",
+                session_id=self.session_id,
+                error=str(e),
+            )
+            raise RuntimeError(f"Failed to fork PTY: {e}") from e
+
+        if self.pid == 0:
+            # Child process - execute command
+            try:
+                # Set up environment
+                if env:
+                    for key, value in env.items():
+                        os.environ[key] = value
+
+                # Set terminal environment
+                os.environ["TERM"] = "xterm-256color"
+                os.environ["COLORTERM"] = "truecolor"
+
+                # Execute command
+                os.execvp(command[0], command)
+            except Exception as e:
+                # If exec fails, log and exit child process
+                traceback.print_exc()
+                sys.stderr.write(f"Failed to execute command {command}: {e}\n")
+                sys.stderr.flush()
+                os._exit(1)
+        else:
+            # Parent process - set up non-blocking I/O
+            flags = fcntl.fcntl(self.master_fd, fcntl.F_GETFL)
+            fcntl.fcntl(self.master_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+            # Set initial size
+            self.resize(self.cols, self.rows)
+
+            # Start reading from PTY
+            self._running = True
+            self._read_task = asyncio.create_task(self._read_from_pty())
+
+            logger.info(
+                "Terminal session started",
+                session_id=self.session_id,
+                pid=self.pid,
+                command=command,
+            )
+
+    async def _read_from_pty(self) -> None:
+        """Continuously read from PTY using event loop's add_reader (non-blocking)"""
+        if self.master_fd is None:
+            return
+
+        loop = asyncio.get_event_loop()
+        read_queue: asyncio.Queue[bytes | None] = asyncio.Queue()
+
+        def read_callback() -> None:
+            """Called by event loop when data is available on the FD"""
+            if self.master_fd is None:
+                return
+            try:
+                data = os.read(self.master_fd, 4096)
+                if data:
+                    # Put data in queue to be processed by async task
+                    read_queue.put_nowait(data)
+                else:
+                    # EOF - PTY closed
+                    read_queue.put_nowait(None)
+            except OSError as e:
+                if e.errno == 11:  # EAGAIN - shouldn't happen with add_reader
+                    pass
+                else:
+                    # PTY closed or error
+                    logger.info(
+                        "PTY read error in callback",
+                        session_id=self.session_id,
+                        error=str(e),
+                        errno=e.errno,
+                    )
+                    read_queue.put_nowait(None)
+            except Exception as e:
+                logger.error(
+                    "Unexpected error in PTY read callback",
+                    session_id=self.session_id,
+                    error=str(e),
+                )
+                read_queue.put_nowait(None)
+
+        # Register the FD with the event loop
+        loop.add_reader(self.master_fd, read_callback)
+
+        try:
+            while self._running:
+                # Wait for data from the queue (non-blocking for event loop)
+                data = await read_queue.get()
+
+                if data is None:
+                    # EOF or error
+                    logger.info(
+                        "PTY closed (EOF)",
+                        session_id=self.session_id,
+                    )
+                    break
+
+                # Process the data
+                decoded = data.decode("utf-8", errors="replace")
+                self.output_callback(decoded)
+        finally:
+            # Unregister the FD from the event loop
+            loop.remove_reader(self.master_fd)
+            logger.info(
+                "PTY read loop exited",
+                session_id=self.session_id,
+                running=self._running,
+            )
+
+    async def write_input(self, data: str) -> None:
+        """Write user input to PTY"""
+        if not self._running or self.master_fd is None:
+            raise RuntimeError(f"Terminal session {self.session_id} not running")
+
+        try:
+            os.write(self.master_fd, data.encode("utf-8"))
+        except OSError as e:
+            logger.error(
+                "Error writing to PTY",
+                session_id=self.session_id,
+                error=str(e),
+            )
+            raise
+
+    def resize(self, cols: int, rows: int) -> None:
+        """Resize the PTY to match terminal dimensions"""
+        if self.master_fd is None:
+            return
+
+        self.cols = cols
+        self.rows = rows
+
+        try:
+            size = struct.pack("HHHH", rows, cols, 0, 0)
+            fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, size)
+            logger.debug(
+                "Terminal resized",
+                session_id=self.session_id,
+                cols=cols,
+                rows=rows,
+            )
+        except Exception as e:
+            logger.error(
+                "Error resizing PTY",
+                session_id=self.session_id,
+                error=str(e),
+            )
+
+    async def stop(self) -> tuple[bool, int | None]:
+        """
+        Stop the terminal session and clean up resources.
+        Returns (success, exit_code)
+        """
+        if not self._running:
+            return True, None
+
+        self._running = False
+
+        # Cancel read task
+        if self._read_task and not self._read_task.done():
+            self._read_task.cancel()
+            try:
+                await self._read_task
+            except asyncio.CancelledError:
+                pass
+
+        exit_code = None
+
+        # Close file descriptor
+        if self.master_fd is not None:
+            try:
+                os.close(self.master_fd)
+            except Exception as e:
+                logger.error(
+                    "Error closing PTY fd",
+                    session_id=self.session_id,
+                    error=str(e),
+                )
+            self.master_fd = None
+
+        # Kill child process
+        if self.pid is not None:
+            try:
+                os.kill(self.pid, signal.SIGTERM)
+                # Wait for process to terminate (with timeout)
+                for _ in range(10):  # Wait up to 1 second
+                    try:
+                        pid, status = os.waitpid(self.pid, os.WNOHANG)
+                        if pid != 0:
+                            exit_code = os.WEXITSTATUS(status)
+                            break
+                    except ChildProcessError:
+                        break
+                    await asyncio.sleep(0.1)
+                else:
+                    # Force kill if still running
+                    try:
+                        os.kill(self.pid, signal.SIGKILL)
+                        os.waitpid(self.pid, 0)
+                    except Exception:
+                        pass
+            except Exception as e:
+                logger.error(
+                    "Error killing PTY process",
+                    session_id=self.session_id,
+                    error=str(e),
+                )
+            self.pid = None
+
+        logger.info(
+            "Terminal session stopped",
+            session_id=self.session_id,
+            exit_code=exit_code,
+        )
+
+        return True, exit_code
+
+    @property
+    def is_running(self) -> bool:
+        """Check if terminal session is running"""
+        return self._running and self.master_fd is not None
+
+
+class TerminalSessionManager:
+    """Manages multiple terminal sessions"""
+
+    def __init__(self, output_queue: asyncio.Queue[TerminalMessage]) -> None:
+        self._sessions: dict[str, TerminalSession] = {}
+        self._lock = asyncio.Lock()
+        self._websocket: object | None = None
+        self._output_queue = output_queue
+
+        # Send reset message immediately to clear stale sessions
+        try:
+            reset_message = TerminalResetSessions()
+            self._output_queue.put_nowait(reset_message)
+            logger.info("Sent TerminalResetSessions message")
+        except asyncio.QueueFull:
+            logger.error("Failed to queue terminal reset message - queue full")
+
+    def set_websocket(self, websocket: object) -> None:
+        """Set the websocket for sending output"""
+        self._websocket = websocket
+
+    async def start_session(
+        self,
+        websocket: object,
+        session_id: str,
+        command: list[str] | None = None,
+        cols: int = 80,
+        rows: int = 24,
+        env: dict[str, str] | None = None,
+    ) -> str:
+        """Start a new terminal session"""
+        async with self._lock:
+            if session_id in self._sessions:
+                raise RuntimeError(f"Terminal session {session_id} already exists")
+
+            # Store websocket reference
+            self._websocket = websocket
+
+            # Create output callback that queues data to be sent
+            def output_callback(data: str) -> None:
+                # Queue the output to be sent asynchronously
+                try:
+                    terminal_output = TerminalOutput(
+                        session_id=session_id,
+                        data=data,
+                        timestamp=time.time(),
+                    )
+                    self._output_queue.put_nowait(terminal_output)
+                except asyncio.QueueFull:
+                    logger.error(
+                        "Terminal output queue full",
+                        session_id=session_id,
+                    )
+
+            session = TerminalSession(
+                session_id=session_id,
+                output_callback=output_callback,
+                cols=cols,
+                rows=rows,
+            )
+
+            await session.start(command=command, env=env)
+            self._sessions[session_id] = session
+
+            return session_id
+
+    async def send_input(self, session_id: str, data: str) -> bool:
+        """Send input to a terminal session"""
+        async with self._lock:
+            session = self._sessions.get(session_id)
+            if session is None:
+                return False
+
+            try:
+                await session.write_input(data)
+                return True
+            except Exception as e:
+                logger.error(
+                    "Failed to send input to terminal",
+                    session_id=session_id,
+                    error=str(e),
+                )
+                return False
+
+    async def resize_terminal(self, session_id: str, rows: int, cols: int) -> bool:
+        """Resize a terminal session"""
+        async with self._lock:
+            session = self._sessions.get(session_id)
+            if session is None:
+                return False
+
+            try:
+                session.resize(cols, rows)
+                return True
+            except Exception as e:
+                logger.error(
+                    "Failed to resize terminal",
+                    session_id=session_id,
+                    error=str(e),
+                )
+                return False
+
+    async def stop_session(self, session_id: str) -> bool:
+        """Stop a terminal session"""
+        async with self._lock:
+            session = self._sessions.pop(session_id, None)
+            if session is None:
+                return True  # Already stopped
+
+            try:
+                await session.stop()
+                return True
+            except Exception as e:
+                logger.error(
+                    "Failed to stop terminal",
+                    session_id=session_id,
+                    error=str(e),
+                )
+                return False
+
+    async def stop_all_sessions(self) -> None:
+        """Stop all terminal sessions (cleanup on disconnect)"""
+        async with self._lock:
+            session_ids = list(self._sessions.keys())
+            for session_id in session_ids:
+                session = self._sessions.pop(session_id, None)
+                if session:
+                    try:
+                        await session.stop()
+                        logger.info(
+                            "Stopped terminal session on cleanup",
+                            session_id=session_id,
+                        )
+                    except Exception as e:
+                        logger.error(
+                            "Error stopping terminal session on cleanup",
+                            session_id=session_id,
+                            error=str(e),
+                        )

indent-0.1.23/exponent/core/remote_execution/terminal_types.py

@@ -0,0 +1,29 @@
+"""Type definitions for terminal output streaming."""
+
+import msgspec
+
+
+class TerminalOutput(msgspec.Struct, tag="terminal_output"):
+    """Terminal output data from CLI to web client."""
+
+    session_id: str
+    data: str
+    timestamp: float
+
+
+class TerminalStatus(msgspec.Struct, tag="terminal_status"):
+    """Terminal status update from CLI to web client."""
+
+    session_id: str
+    status: str
+    message: str
+    exit_code: int | None = None
+
+
+class TerminalResetSessions(msgspec.Struct, tag="terminal_reset_sessions"):
+    """Sent from CLI when terminal session manager starts to clear stale sessions."""
+
+    # No fields needed - just a signal
+
+
+TerminalMessage = TerminalOutput | TerminalStatus | TerminalResetSessions

{indent-0.1.22 → indent-0.1.23}/exponent/core/remote_execution/tool_execution.py

@@ -32,15 +32,15 @@ from exponent.core.remote_execution.cli_rpc_types import (
 
 if TYPE_CHECKING:
     from exponent.core.remote_execution.client import RemoteExecutionClient
+from exponent.core.remote_execution.cli_rpc_types import (
+    StreamingCodeExecutionRequest,
+    StreamingCodeExecutionResponse,
+)
 from exponent.core.remote_execution.code_execution import (
     execute_code_streaming,
 )
 from exponent.core.remote_execution.file_write import execute_full_file_rewrite
 from exponent.core.remote_execution.truncation import truncate_tool_result
-from exponent.core.remote_execution.types import (
-    StreamingCodeExecutionRequest,
-    StreamingCodeExecutionResponse,
-)
 from exponent.core.remote_execution.utils import (
     assert_unreachable,
     safe_get_file_metadata,

{indent-0.1.22 → indent-0.1.23}/exponent/core/remote_execution/truncation.py

@@ -17,7 +17,7 @@ from exponent.core.remote_execution.cli_rpc_types import (
 )
 from exponent.core.remote_execution.utils import truncate_output
 
-DEFAULT_CHARACTER_LIMIT = 90_000
+DEFAULT_CHARACTER_LIMIT = 50_000
 DEFAULT_LIST_ITEM_LIMIT = 1000
 DEFAULT_LIST_PREVIEW_ITEMS = 10