indent 0.1.13__py3-none-any.whl → 0.1.28__py3-none-any.whl

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,

exponent/core/remote_execution/default_env.py

@@ -0,0 +1,31 @@
+import os
+
+
+def get_default_env() -> dict[str, str]:
+    """
+    Returns default environment variables for CLI-spawned processes.
+    These are merged with the parent process environment.
+    """
+    return {
+        "GIT_EDITOR": "true",
+    }
+
+
+def get_process_env(env_overrides: dict[str, str] | None = None) -> dict[str, str]:
+    """
+    Returns the complete environment for spawned processes.
+    Merges parent environment with default variables, then applies overrides.
+
+    Priority order (lowest to highest):
+    1. Parent process environment (os.environ)
+    2. Default environment variables (get_default_env())
+    3. Explicit overrides (env_overrides parameter)
+
+    Args:
+        env_overrides: Optional dict of environment variables that override defaults
+    """
+    env = os.environ.copy()
+    env.update(get_default_env())
+    if env_overrides:
+        env.update(env_overrides)
+    return env

exponent/core/remote_execution/languages/shell_streaming.py

@@ -6,6 +6,7 @@ import signal
 from collections.abc import AsyncGenerator, Callable
 from typing import Any
 
+from exponent.core.remote_execution.default_env import get_process_env
 from exponent.core.remote_execution.languages.types import (
     ShellExecutionResult,
     StreamedOutputPiece,
@@ -49,10 +50,10 @@ 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)
+            chunk = data.decode(encoding=encoding, errors="replace")
             output.append((fd, chunk))
             yield StreamedOutputPiece(content=chunk)
         except UnicodeDecodeError:
@@ -80,6 +81,7 @@ async def execute_shell_streaming(  # noqa: PLR0915
     working_directory: str,
     timeout: int,
     should_halt: Callable[[], bool] | None = None,
+    env: dict[str, str] | None = None,
 ) -> AsyncGenerator[StreamedOutputPiece | ShellExecutionResult, None]:
     timeout_seconds = min(timeout, MAX_TIMEOUT)
 
@@ -91,6 +93,7 @@ async def execute_shell_streaming(  # noqa: PLR0915
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
             cwd=working_directory,
+            env=get_process_env(env),
         )
     else:
         # Add rc file sourcing to the command
@@ -105,6 +108,7 @@ async def execute_shell_streaming(  # noqa: PLR0915
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
             cwd=working_directory,
+            env=get_process_env(env),
             start_new_session=True if platform.system() != "Windows" else False,
         )
 
@@ -149,7 +153,10 @@ async def execute_shell_streaming(  # noqa: PLR0915
     def on_timeout() -> None:
         nonlocal timed_out
         timed_out = True
-        process.kill()
+        try:
+            process.kill()
+        except ProcessLookupError:
+            pass
 
     try:
         halt_task = asyncio.create_task(monitor_halt()) if should_halt else None
@@ -175,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)

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(),
     )