Shell Fix

agent/shell.py

@@ -2,12 +2,17 @@
 
 from __future__ import annotations
 
+import shutil
 import subprocess
+import tempfile
 import threading
 import time
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import IO
 
+IDLE_TIMEOUT_SECONDS = 15 * 60  # 15 minutes
+
 
 @dataclass
 class ShellSession:
@@ -15,9 +20,11 @@ class ShellSession:
 
     session_id: str
     process: subprocess.Popen[str]
+    temp_dir: Path
     output_buffer: list[str] = field(default_factory=list)
     last_read_pos: int = 0
     started_at: float = field(default_factory=time.time)
+    last_used_at: float = field(default_factory=time.time)
     closed: bool = False
 
     @property
@@ -28,22 +35,32 @@ class ShellSession:
     def returncode(self) -> int | None:
         return self.process.returncode
 
+    def touch(self) -> None:
+        """Update last_used_at to current time."""
+        self.last_used_at = time.time()
+
     def read_new_output(self) -> str:
         """Read new output since last read."""
+        self.touch()
         new_lines = self.output_buffer[self.last_read_pos :]
         self.last_read_pos = len(self.output_buffer)
         return "".join(new_lines)
 
     def get_full_output(self) -> str:
         """Get all output."""
+        self.touch()
         return "".join(self.output_buffer)
 
     def is_running(self) -> bool:
         """Check if process is still running."""
         return self.process.poll() is None
 
+    def is_idle_expired(self) -> bool:
+        """Check if session has been idle longer than IDLE_TIMEOUT_SECONDS."""
+        return (time.time() - self.last_used_at) > IDLE_TIMEOUT_SECONDS
+
     def close(self) -> None:
-        """Close the session."""
+        """Close the session and clean up temp directory."""
         if not self.closed:
             self.closed = True
             try:
@@ -54,6 +71,14 @@ class ShellSession:
                     self.process.kill()
                 except Exception:
                     pass
+            # Clean up temp directory (retry a few times for Windows file locks)
+            if self.temp_dir.exists():
+                for _ in range(3):
+                    try:
+                        shutil.rmtree(self.temp_dir, ignore_errors=False)
+                        break
+                    except Exception:
+                        time.sleep(0.1)
 
 
 class ShellManager:
@@ -63,6 +88,29 @@ class ShellManager:
         self.sessions: dict[str, ShellSession] = {}
         self._lock = threading.Lock()
         self.default_timeout = default_timeout
+        self._cleanup_thread = threading.Thread(
+            target=self._cleanup_loop, daemon=True
+        )
+        self._cleanup_thread.start()
+
+    def _cleanup_loop(self) -> None:
+        """Background thread that cleans up idle sessions every 60 seconds."""
+        while True:
+            time.sleep(60)
+            self._cleanup_idle_sessions()
+
+    def _cleanup_idle_sessions(self) -> None:
+        """Close sessions that have been idle for more than IDLE_TIMEOUT_SECONDS."""
+        with self._lock:
+            idle_sessions = [
+                sid
+                for sid, session in self.sessions.items()
+                if session.is_idle_expired()
+            ]
+            for sid in idle_sessions:
+                session = self.sessions.pop(sid, None)
+                if session:
+                    session.close()
 
     def start(
         self,
@@ -71,12 +119,21 @@ class ShellManager:
         cwd: str | None = None,
         env: dict[str, str] | None = None,
     ) -> ShellSession:
-        """Start a new shell session."""
+        """Start a new shell session in a fresh temp directory."""
         with self._lock:
             # Close existing session with same ID
             if session_id in self.sessions:
                 self.sessions[session_id].close()
 
+            # Create a unique temp directory for this session
+            temp_dir = Path(tempfile.mkdtemp(prefix=f"shell_{session_id}_"))
+
+            # Merge env with inherited environment
+            import os
+            process_env = os.environ.copy()
+            if env:
+                process_env.update(env)
+
             # Use shell=True for interactive commands
             process = subprocess.Popen(
                 command,
@@ -86,11 +143,15 @@ class ShellManager:
                 stderr=subprocess.STDOUT,
                 text=True,
                 bufsize=1,
-                cwd=cwd,
-                env=env,
+                cwd=str(temp_dir),
+                env=process_env,
             )
 
-            session = ShellSession(session_id=session_id, process=process)
+            session = ShellSession(
+                session_id=session_id,
+                process=process,
+                temp_dir=temp_dir,
+            )
             self.sessions[session_id] = session
 
             # Start output reader thread
@@ -125,6 +186,7 @@ class ShellManager:
             try:
                 session.process.stdin.write(input_text + "\n")
                 session.process.stdin.flush()
+                session.touch()
                 return True
             except Exception:
                 return False

agent/tools.py

@@ -179,21 +179,23 @@ from .shell import get_shell_manager
 
 
 def _shell_handler(
-    command: str,
+    command: str = "",
     session_id: str = "",
     input_text: str = "",
 ) -> str:
-    """Run shell commands interactively.
+    """Run shell commands interactively with persistent sessions.
 
-    command (required): The shell command to execute (omit when checking output or sending input)
+    command: The shell command to execute (omit when checking output or sending input)
     session_id: Session ID to check output or send input to (omit to start new command)
     input_text: Text to send to running session's stdin
 
     How it works:
-    - Start new command: returns session_id immediately (non-blocking)
-    - Check output: call with session_id to get current output
-    - Send input: call with session_id + input_text
-    - Command runs in background, never blocks the agent
+    - Start new command: provide command, returns session_id immediately (non-blocking)
+    - Check output: provide session_id only, returns current output
+    - Send input: provide session_id + input_text
+    - Sessions auto-destroy after 15 min idle
+    - Each session runs in its own temp folder (also cleaned up on timeout)
+    - Environment variables persist across calls in the same session
     """
     manager = get_shell_manager()
 
@@ -203,7 +205,7 @@ def _shell_handler(
     if existing_session and input_text:
         sent = manager.send_input(session_id, input_text)
         if not sent:
-            return f"Error: Session '{session_id}' closed"
+            return f"Error: Session '{session_id}' closed or not found"
         time.sleep(0.3)
         output = manager.poll_output(session_id)
         running = manager.is_running(session_id)
@@ -222,6 +224,12 @@ def _shell_handler(
             return f"[{session_id}] {status}:\n{output}"
         return f"[{session_id}] {status}"
 
+    # Need a command to start a new session
+    if not command.strip():
+        if session_id:
+            return f"Error: Session '{session_id}' not found or expired"
+        return "Error: Provide a command to start a new session, or a session_id to check status"
+
     # Start new command
     sid = session_id or str(_uuid.uuid4())[:8]
     session = manager.start(sid, command)
@@ -248,24 +256,24 @@ def _shell_handler(
 
 SHELL_TOOL = Tool(
     name="shell",
-    description="Run shell commands interactively. Start command -> returns session_id. Call again with session_id to check output or send input. Never blocks.",
+    description="Run shell commands with persistent sessions. Start command -> get session_id. Call with session_id to check output or send input. Sessions auto-destroy after 15 min idle. Each session has its own temp folder.",
     parameters={
         "type": "object",
         "properties": {
             "command": {
                 "type": "string",
-                "description": "The shell command to execute (omit when checking output or sending input)",
+                "description": "Shell command to execute (omit when checking output or sending input)",
             },
             "session_id": {
                 "type": "string",
-                "description": "Session ID to check output or send input to (omit to start new command)",
+                "description": "Session ID to check output or send input (omit to start new command)",
             },
             "input_text": {
                 "type": "string",
                 "description": "Text to send to running session's stdin",
             },
         },
-        "required": ["command"],
+        "required": [],
     },
     handler=_shell_handler,
     streamable=False,

app.css

@@ -19,7 +19,7 @@ html, body {
 }
 
 #main-row {
-  height: calc(var(--vh) * 100);
+  height: var(--vh, 100%);
   max-height: 100%;
 }
 

static/js/landing.js

@@ -75,7 +75,7 @@
     function setVH() {
         document.documentElement.style.setProperty(
             '--vh',
-            `${window.innerHeight * 0.01}px`
+            `${window.innerHeight}px`
         );
     }