indent 0.1.21__py3-none-any.whl → 0.1.24__py3-none-any.whl

exponent/core/remote_execution/port_utils.py

@@ -0,0 +1,73 @@
+import time
+
+import psutil
+
+from exponent.core.remote_execution.types import PortInfo
+
+
+def get_port_usage() -> list[PortInfo] | None:
+    """
+    Get information about all listening ports on the system.
+
+    Returns:
+        List of PortInfo objects containing process name, port, protocol, pid, and uptime.
+        Returns None if there's a permission error.
+        Returns empty list if no listening ports are found.
+    """
+    try:
+        connections = psutil.net_connections(kind="tcp")
+    except (psutil.AccessDenied, PermissionError):
+        # If we don't have permission to see connections, return None
+        return None
+    except Exception:
+        # For any other unexpected errors, return None
+        return None
+
+    port_info_list: list[PortInfo] = []
+    current_time = time.time()
+
+    for conn in connections:
+        # Only include TCP ports in LISTEN state
+        if conn.status != "LISTEN":
+            continue
+
+        # Skip if no local address (shouldn't happen for LISTEN, but be safe)
+        if not conn.laddr:
+            continue
+
+        port = conn.laddr.port
+        pid = conn.pid
+
+        # Try to get process information
+        process_name = "unknown"
+        uptime_seconds = None
+
+        if pid:
+            try:
+                process = psutil.Process(pid)
+                process_name = process.name()
+
+                # Calculate uptime
+                create_time = process.create_time()
+                uptime_seconds = current_time - create_time
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                # Process disappeared or we don't have permission
+                pass
+            except Exception:
+                # Any other unexpected error, just skip process info
+                pass
+
+        port_info = PortInfo(
+            process_name=process_name,
+            port=port,
+            protocol="TCP",
+            pid=pid,
+            uptime_seconds=uptime_seconds,
+        )
+        port_info_list.append(port_info)
+
+        # Limit to 50 ports to avoid bloating the heartbeat payload
+        if len(port_info_list) >= 50:
+            break
+
+    return port_info_list

exponent/core/remote_execution/system_context.py

@@ -4,6 +4,7 @@ import platform
 
 from exponent.core.remote_execution.git import get_git_info
 from exponent.core.remote_execution.languages import python_execution
+from exponent.core.remote_execution.port_utils import get_port_usage
 from exponent.core.remote_execution.types import (
     SystemInfo,
 )
@@ -17,6 +18,7 @@ async def get_system_info(working_directory: str) -> SystemInfo:
         shell=_get_user_shell(),
         git=await get_git_info(working_directory),
         python_env=python_execution.get_python_env_info(),
+        port_usage=get_port_usage(),
     )
 
 

exponent/core/remote_execution/terminal_session.py

@@ -0,0 +1,428 @@
+import asyncio
+import fcntl
+import logging
+import os
+import pty
+import signal
+import struct
+import sys
+import termios
+import time
+import traceback
+from collections.abc import Callable
+
+from exponent.core.remote_execution.terminal_types import (
+    TerminalMessage,
+    TerminalOutput,
+    TerminalResetSessions,
+)
+
+logger = logging.getLogger(__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),
+                        )

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

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,

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
 

exponent/core/remote_execution/types.py

@@ -120,6 +120,14 @@ class PythonEnvInfo(BaseModel):
     provider: Literal["venv", "pyenv", "pipenv", "conda"] | None = "pyenv"
 
 
+class PortInfo(BaseModel):
+    process_name: str
+    port: int
+    protocol: str
+    pid: int | None
+    uptime_seconds: float | None
+
+
 class SystemInfo(BaseModel):
     name: str
     cwd: str
@@ -127,6 +135,7 @@ class SystemInfo(BaseModel):
     shell: str
     git: GitInfo | None
     python_env: PythonEnvInfo | None
+    port_usage: list[PortInfo] | None = None
 
 
 class HeartbeatInfo(BaseModel):

{indent-0.1.21.dist-info → indent-0.1.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: indent
-Version: 0.1.21
+Version: 0.1.24
 Summary: Indent is an AI Pair Programmer
 Author-email: Sashank Thupukari <sashank@exponent.run>
 Requires-Python: <3.13,>=3.10
@@ -22,6 +22,7 @@ Requires-Dist: msgspec>=0.19.0
 Requires-Dist: packaging~=24.1
 Requires-Dist: pip<26,>=25.0.1
 Requires-Dist: prompt-toolkit<4,>=3.0.36
+Requires-Dist: psutil<7,>=5.9.0
 Requires-Dist: pydantic-ai==0.0.30
 Requires-Dist: pydantic-settings<3,>=2.2.1
 Requires-Dist: pydantic[email]<3,>=2.6.4

{indent-0.1.21.dist-info → indent-0.1.24.dist-info}/RECORD

@@ -1,7 +1,7 @@
-exponent/__init__.py,sha256=QwRysHnO-cJwIFSvXReHDj93DEPhlibOTtnnb25J9-c,706
+exponent/__init__.py,sha256=IV4a2R7tlzuACf6FAyPEbprLKNroeE-n_UPSKi1QJSc,706
 exponent/cli.py,sha256=QnIeDTgWaQJrRs5WESCkQpVEQiJiAO4qWgB0rYlkd78,3344
 exponent/py.typed,sha256=9XZl5avs8yHp89XP_1Fjtbeg_2rjYorCC9I0k_j-h2c,334
-exponent/commands/cloud_commands.py,sha256=_qivNDIHIJXxLgVUm5vUNyuzG15llMqB8xY2MZ7F_lc,16710
+exponent/commands/cloud_commands.py,sha256=yd0d7l8AaFZIgrFPRYspsKlmcyFqkK_ovSQKhK-YpVU,16773
 exponent/commands/common.py,sha256=M2KI9yKjB8fecPoDBphMa123c35-iNeaE9q4DxhkaFU,12817
 exponent/commands/config_commands.py,sha256=mmQYuyRosODgawoHWsn9xnWnV37GiQaxJjMv-_xreAU,8902
 exponent/commands/run_commands.py,sha256=xn0SJX0PPrmHu8Nh-kG-lJBhGC4qFCc04aLIzdVyFho,6389
@@ -13,13 +13,13 @@ exponent/core/config.py,sha256=TNFLUgLnfSocRMVSav_7E4VcaNHXZ_3Mg5Lp1smP46U,5731
 exponent/core/graphql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 exponent/core/graphql/client.py,sha256=SRagD3YPyoYZSO1RtfO-OXD7b5dm1NvgoL6CTbN380o,2009
 exponent/core/graphql/get_chats_query.py,sha256=9-2N1VfapXUZB3IFIKw5U_gKdmfyviJp5JSUntB_Yyk,1177
-exponent/core/graphql/mutations.py,sha256=eVoazBZowqLk3Jz-67tR_ATqrQKPhk5Teeq7YV-70b0,2931
+exponent/core/graphql/mutations.py,sha256=Szs8wS_5EpVuZdt09QbstIm_8i-_-EGT4Z17pou5714,2971
 exponent/core/graphql/queries.py,sha256=RYsk8bub0esspqgakilhzX07yJf2652Ey9tBZK1l_lY,3297
 exponent/core/graphql/subscriptions.py,sha256=SQngv_nYVNJjiZ_P2k0UcLIu1pzc4vi7q7lhH89NCZM,393
 exponent/core/remote_execution/checkpoints.py,sha256=3QGYMLa8vT7XmxMYTRcGrW8kNGHwRC0AkUfULribJWg,6354
-exponent/core/remote_execution/cli_rpc_types.py,sha256=1HPLLtzpeGJfkh8nXlo8d_zDajzfDIwLu83Cfm60Cnc,8642
-exponent/core/remote_execution/client.py,sha256=dG2ueANYJH8CznDT5L3-UApkWZ25ANheSvv62JCMq9c,32038
-exponent/core/remote_execution/code_execution.py,sha256=jYPB_7dJzS9BTPLX9fKQpsFPatwjbXuaFFSxT9tDTfI,2388
+exponent/core/remote_execution/cli_rpc_types.py,sha256=RPlvZYb7KLYlb65I8wcVAlkv3cSB7n2okZqMeWz_V4c,11791
+exponent/core/remote_execution/client.py,sha256=bUl2w28c_okWndW9jEreVyYKeFNyL8h8OMZNBb4lf3g,40307
+exponent/core/remote_execution/code_execution.py,sha256=QL78v2yHMrIcbNWIczAICWRceziXgG4pzw7gvhUOLxs,3328
 exponent/core/remote_execution/default_env.py,sha256=s44A1Cz9EgYuhF17WO3ESVNSLQw57EoOLyi9k6qliIo,911
 exponent/core/remote_execution/error_info.py,sha256=Rd7OA3ps06qYejPVcOaMBB9AtftP3wqQoOfiILFASnc,1378
 exponent/core/remote_execution/exceptions.py,sha256=eT57lBnBhvh-KJ5lsKWcfgGA5-WisAxhjZx-Z6OupZY,135
@@ -27,15 +27,18 @@ exponent/core/remote_execution/file_write.py,sha256=8Sa70ANIDHGxIAq4_Uy2Qoo55K7-
 exponent/core/remote_execution/files.py,sha256=mIVjhStaEKETW6y3pCVeV8eJKNaPtroWGP_kBK1x8uA,8776
 exponent/core/remote_execution/git.py,sha256=dGjBpeoKJZsYgRwctSq29GmbsNIN9tbSA3VwBnRD0IQ,7810
 exponent/core/remote_execution/http_fetch.py,sha256=aFEyXd0S-MRfisSMuIFiEyc1AEAj9nUZ9Rj_P_YRows,2827
+exponent/core/remote_execution/port_utils.py,sha256=kWje8ikCzBXMeS7qr6NZZOzQOMoMuacgPUDYyloYgwM,2183
 exponent/core/remote_execution/session.py,sha256=jlQIdeUj0f7uOk3BgzlJtBJ_GyTIjCchBp5ApQuF2-I,3847
-exponent/core/remote_execution/system_context.py,sha256=QY1zY8_fWj3sh-fmLYtewvgxh7uTX4ITIJqlUTDkj6c,648
-exponent/core/remote_execution/tool_execution.py,sha256=DVO7jPS6JUGjY3GTevvNn5NlieKDOcx8id_nhi9x6Og,15783
+exponent/core/remote_execution/system_context.py,sha256=I4RNuM60isS-529EuRrrEPPwJssNFC2TZ_7MhBTWEd0,754
+exponent/core/remote_execution/terminal_session.py,sha256=Bva8D9lPjq-HXktxvjtK6xn7z3CsDVKyl1hxJV2-67M,14213
+exponent/core/remote_execution/terminal_types.py,sha256=t4snBiTtidAEJZTvy789x-5HFqjkV9rlonjDO30PfAY,731
+exponent/core/remote_execution/tool_execution.py,sha256=tDVW1c4ZysfTZqbR-wd7et41Mfv1lFQJCBvQShWnWq4,15791
 exponent/core/remote_execution/tool_type_utils.py,sha256=7qi6Qd8fvHts019ZSLPbtiy17BUqgqBg3P_gdfvFf7w,1301
-exponent/core/remote_execution/truncation.py,sha256=crHzjcUxL3tVe8yuoWNAE5r-uQKjtL-GzZczd-ucrd0,9849
-exponent/core/remote_execution/types.py,sha256=fUT5-3TE3sA2dUqWaen9VgpEllz4RA0B3i-FJpEEXOs,15601
+exponent/core/remote_execution/truncation.py,sha256=0zFnmqXES2vtQCSpfXIQn5hgg6bZK4Sad_Cfh27xTZU,9849
+exponent/core/remote_execution/types.py,sha256=2tp73g6WLhL3x-5FyP9jhadcRHIswt4wfJJlEvNwlvk,15782
 exponent/core/remote_execution/utils.py,sha256=6PlBqYJ3OQwZ0dgXiIu3br04a-d-glDeDZpD0XGGPAE,14793
 exponent/core/remote_execution/languages/python_execution.py,sha256=nsX_LsXcUcHhiEHpSTjOTVNd7CxM146al0kw_iQX5OU,7724
-exponent/core/remote_execution/languages/shell_streaming.py,sha256=gBACa5uFMGuQzEFpKE61ww6niHWFe58NToI1HaIYGVU,7662
+exponent/core/remote_execution/languages/shell_streaming.py,sha256=MpE1XQiu18xWUGp1wD_Hb1nuPCQE-i5-_XO6FnkcNvo,7675
 exponent/core/remote_execution/languages/types.py,sha256=f7FjSRNRSga-ZaE3LddDhxCirUVjlSYMEdoskG6Pta4,314
 exponent/core/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 exponent/core/types/command_data.py,sha256=_HqQsnamRZeVoVaTpeO3ecVUzNBdG62WXlFy6Q7rtUM,5294
@@ -46,7 +49,7 @@ exponent/migration-docs/login.md,sha256=KIeXy3m2nzSUgw-4PW1XzXfHael1D4Zu93CplLMb
 exponent/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 exponent/utils/colors.py,sha256=HBkqe_ZmhJ9YiL2Fpulqek4KvLS5mwBTY4LQSM5N8SM,2762
 exponent/utils/version.py,sha256=GHZ9ET1kMyDubJZU3w2sah5Pw8XpiEakS5IOlt3wUnQ,8888
-indent-0.1.21.dist-info/METADATA,sha256=kUlmIYOdjCG1iPkNC0oFscWTh9tsFMVuFUG_MPmNltQ,1308
-indent-0.1.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-indent-0.1.21.dist-info/entry_points.txt,sha256=q8q1t1sbl4NULGOR0OV5RmSG4KEjkpEQRU_RUXEGzcs,44
-indent-0.1.21.dist-info/RECORD,,
+indent-0.1.24.dist-info/METADATA,sha256=ifMj-YDEk36Exlumd1dldLvl6FdXZfWWZPI_BSTHO-Y,1340
+indent-0.1.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+indent-0.1.24.dist-info/entry_points.txt,sha256=q8q1t1sbl4NULGOR0OV5RmSG4KEjkpEQRU_RUXEGzcs,44
+indent-0.1.24.dist-info/RECORD,,