claude-mpm 3.1.2__py3-none-any.whl → 3.2.1__py3-none-any.whl

claude_mpm/core/simple_runner.py

@@ -1,4 +1,4 @@
-"""Simplified Claude runner replacing the complex orchestrator system."""
+"""Claude runner with both exec and subprocess launch methods."""
 
 import json
 import os
@@ -8,6 +8,7 @@ import time
 from datetime import datetime
 from pathlib import Path
 from typing import Optional
+import uuid
 
 try:
     from claude_mpm.services.agent_deployment import AgentDeploymentService
@@ -19,28 +20,38 @@ except ImportError:
     from claude_mpm.core.logger import get_logger, get_project_logger, ProjectLogger
 
 
-class SimpleClaudeRunner:
+class ClaudeRunner:
     """
-    Simplified Claude runner that replaces the entire orchestrator system.
+    Claude runner that replaces the entire orchestrator system.
     
     This does exactly what we need:
     1. Deploy native agents to .claude/agents/
-    2. Run Claude CLI with basic subprocess calls
+    2. Run Claude CLI with either exec or subprocess
     3. Extract tickets if needed
     4. Handle both interactive and non-interactive modes
+    
+    Supports two launch methods:
+    - exec: Replace current process (default for backward compatibility)
+    - subprocess: Launch as child process for more control
     """
     
     def __init__(
         self,
         enable_tickets: bool = True,
         log_level: str = "OFF",
-        claude_args: Optional[list] = None
+        claude_args: Optional[list] = None,
+        launch_method: str = "exec",  # "exec" or "subprocess"
+        enable_websocket: bool = False,
+        websocket_port: int = 8765
     ):
-        """Initialize the simple runner."""
+        """Initialize the Claude runner."""
         self.enable_tickets = enable_tickets
         self.log_level = log_level
-        self.logger = get_logger("simple_runner")
+        self.logger = get_logger("claude_runner")
         self.claude_args = claude_args or []
+        self.launch_method = launch_method
+        self.enable_websocket = enable_websocket
+        self.websocket_port = websocket_port
         
         # Initialize project logger for session logging
         self.project_logger = None
@@ -48,7 +59,7 @@ class SimpleClaudeRunner:
             try:
                 self.project_logger = get_project_logger(log_level)
                 self.project_logger.log_system(
-                    "Initializing SimpleClaudeRunner",
+                    f"Initializing ClaudeRunner with {launch_method} launcher",
                     level="INFO",
                     component="runner"
                 )
@@ -76,12 +87,16 @@ class SimpleClaudeRunner:
                 self.session_log_file = self.project_logger.session_dir / "system.jsonl"
                 self._log_session_event({
                     "event": "session_start",
-                    "runner": "SimpleClaudeRunner",
+                    "runner": "ClaudeRunner",
                     "enable_tickets": enable_tickets,
-                    "log_level": log_level
+                    "log_level": log_level,
+                    "launch_method": launch_method
                 })
             except Exception as e:
                 self.logger.debug(f"Failed to create session log file: {e}")
+        
+        # Initialize WebSocket server reference
+        self.websocket_server = None
     
     def setup_agents(self) -> bool:
         """Deploy native agents to .claude/agents/."""
@@ -137,6 +152,28 @@ class SimpleClaudeRunner:
     
     def run_interactive(self, initial_context: Optional[str] = None):
         """Run Claude in interactive mode."""
+        # Start WebSocket server if enabled
+        if self.enable_websocket:
+            try:
+                # Lazy import to avoid circular dependencies
+                from claude_mpm.services.websocket_server import WebSocketServer
+                self.websocket_server = WebSocketServer(port=self.websocket_port)
+                self.websocket_server.start()
+                
+                # Generate session ID
+                session_id = str(uuid.uuid4())
+                working_dir = os.getcwd()
+                
+                # Notify session start
+                self.websocket_server.session_started(
+                    session_id=session_id,
+                    launch_method=self.launch_method,
+                    working_dir=working_dir
+                )
+            except Exception as e:
+                self.logger.warning(f"Failed to start WebSocket server: {e}")
+                self.websocket_server = None
+        
         # Get version
         try:
             from claude_mpm import __version__
@@ -210,17 +247,35 @@ class SimpleClaudeRunner:
             
             if self.project_logger:
                 self.project_logger.log_system(
-                    "Launching Claude interactive mode",
+                    f"Launching Claude interactive mode with {self.launch_method}",
                     level="INFO",
                     component="session"
                 )
                 self._log_session_event({
                     "event": "launching_claude_interactive",
-                    "command": " ".join(cmd)
+                    "command": " ".join(cmd),
+                    "method": self.launch_method
                 })
             
-            # Replace current process with Claude
-            os.execvpe(cmd[0], cmd, clean_env)
+            # Notify WebSocket clients
+            if self.websocket_server:
+                self.websocket_server.claude_status_changed(
+                    status="starting",
+                    message="Launching Claude interactive session"
+                )
+            
+            # Launch using selected method
+            if self.launch_method == "subprocess":
+                self._launch_subprocess_interactive(cmd, clean_env)
+            else:
+                # Default to exec for backward compatibility
+                if self.websocket_server:
+                    # Notify before exec (we won't be able to after)
+                    self.websocket_server.claude_status_changed(
+                        status="running",
+                        message="Claude process started (exec mode)"
+                    )
+                os.execvpe(cmd[0], cmd, clean_env)
             
         except Exception as e:
             print(f"Failed to launch Claude: {e}")
@@ -235,6 +290,13 @@ class SimpleClaudeRunner:
                     "error": str(e),
                     "exception_type": type(e).__name__
                 })
+            
+            # Notify WebSocket clients of error
+            if self.websocket_server:
+                self.websocket_server.claude_status_changed(
+                    status="error",
+                    message=f"Failed to launch Claude: {e}"
+                )
             # Fallback to subprocess
             try:
                 # Use the same clean_env we prepared earlier
@@ -267,6 +329,28 @@ class SimpleClaudeRunner:
         """Run Claude with a single prompt and return success status."""
         start_time = time.time()
         
+        # Start WebSocket server if enabled
+        if self.enable_websocket:
+            try:
+                # Lazy import to avoid circular dependencies
+                from claude_mpm.services.websocket_server import WebSocketServer
+                self.websocket_server = WebSocketServer(port=self.websocket_port)
+                self.websocket_server.start()
+                
+                # Generate session ID
+                session_id = str(uuid.uuid4())
+                working_dir = os.getcwd()
+                
+                # Notify session start
+                self.websocket_server.session_started(
+                    session_id=session_id,
+                    launch_method="oneshot",
+                    working_dir=working_dir
+                )
+            except Exception as e:
+                self.logger.warning(f"Failed to start WebSocket server: {e}")
+                self.websocket_server = None
+        
         # Check for /mpm: commands
         if prompt.strip().startswith("/mpm:"):
             return self._handle_mpm_command(prompt.strip())
@@ -335,6 +419,13 @@ class SimpleClaudeRunner:
                     component="session"
                 )
             
+            # Notify WebSocket clients
+            if self.websocket_server:
+                self.websocket_server.claude_status_changed(
+                    status="running",
+                    message="Executing Claude oneshot command"
+                )
+            
             result = subprocess.run(cmd, capture_output=True, text=True, env=env)
             
             # Restore original directory if we changed it
@@ -349,6 +440,10 @@ class SimpleClaudeRunner:
                 response = result.stdout.strip()
                 print(response)
                 
+                # Broadcast output to WebSocket clients
+                if self.websocket_server and response:
+                    self.websocket_server.claude_output(response, "stdout")
+                
                 if self.project_logger:
                     # Log successful completion
                     self.project_logger.log_system(
@@ -378,6 +473,17 @@ class SimpleClaudeRunner:
                             "indicators": [p for p in ["Task(", "subagent_type=", "engineer agent", "qa agent"] 
                                           if p.lower() in response.lower()]
                         })
+                        
+                        # Notify WebSocket clients about delegation
+                        if self.websocket_server:
+                            # Try to extract agent name
+                            agent_name = self._extract_agent_from_response(response)
+                            if agent_name:
+                                self.websocket_server.agent_delegated(
+                                    agent=agent_name,
+                                    task=prompt[:100],
+                                    status="detected"
+                                )
                 
                 # Extract tickets if enabled
                 if self.enable_tickets and self.ticket_manager and response:
@@ -388,6 +494,14 @@ class SimpleClaudeRunner:
                 error_msg = result.stderr or "Unknown error"
                 print(f"Error: {error_msg}")
                 
+                # Broadcast error to WebSocket clients
+                if self.websocket_server:
+                    self.websocket_server.claude_output(error_msg, "stderr")
+                    self.websocket_server.claude_status_changed(
+                        status="error",
+                        message=f"Command failed with code {result.returncode}"
+                    )
+                
                 if self.project_logger:
                     self.project_logger.log_system(
                         f"Non-interactive session failed: {error_msg}",
@@ -433,6 +547,14 @@ class SimpleClaudeRunner:
                     )
                 except Exception as e:
                     self.logger.debug(f"Failed to log session summary: {e}")
+            
+            # End WebSocket session
+            if self.websocket_server:
+                self.websocket_server.claude_status_changed(
+                    status="stopped",
+                    message="Session completed"
+                )
+                self.websocket_server.session_ended()
     
     def _extract_tickets(self, text: str):
         """Extract tickets from Claude's response."""
@@ -519,6 +641,28 @@ class SimpleClaudeRunner:
         text_lower = text.lower()
         return any(pattern.lower() in text_lower for pattern in delegation_patterns)
     
+    def _extract_agent_from_response(self, text: str) -> Optional[str]:
+        """Try to extract agent name from delegation response."""
+        # Look for common patterns
+        import re
+        
+        # Pattern 1: subagent_type="agent_name"
+        match = re.search(r'subagent_type=["\']([^"\']*)["\'\)]', text)
+        if match:
+            return match.group(1)
+        
+        # Pattern 2: "engineer agent" etc
+        agent_names = [
+            "engineer", "qa", "documentation", "research", 
+            "security", "ops", "version_control", "data_engineer"
+        ]
+        text_lower = text.lower()
+        for agent in agent_names:
+            if f"{agent} agent" in text_lower or f"agent: {agent}" in text_lower:
+                return agent
+        
+        return None
+    
     def _handle_mpm_command(self, prompt: str) -> bool:
         """Handle /mpm: commands directly without going to Claude."""
         try:
@@ -594,6 +738,138 @@ class SimpleClaudeRunner:
                     f.write(json.dumps(log_entry) + '\n')
             except Exception as e:
                 self.logger.debug(f"Failed to log session event: {e}")
+    
+    def _launch_subprocess_interactive(self, cmd: list, env: dict):
+        """Launch Claude as a subprocess with PTY for interactive mode."""
+        import pty
+        import select
+        import termios
+        import tty
+        import signal
+        
+        # Save original terminal settings
+        original_tty = None
+        if sys.stdin.isatty():
+            original_tty = termios.tcgetattr(sys.stdin)
+        
+        # Create PTY
+        master_fd, slave_fd = pty.openpty()
+        
+        try:
+            # Start Claude process
+            process = subprocess.Popen(
+                cmd,
+                stdin=slave_fd,
+                stdout=slave_fd,
+                stderr=slave_fd,
+                env=env
+            )
+            
+            # Close slave in parent
+            os.close(slave_fd)
+            
+            if self.project_logger:
+                self.project_logger.log_system(
+                    f"Claude subprocess started with PID {process.pid}",
+                    level="INFO",
+                    component="subprocess"
+                )
+            
+            # Notify WebSocket clients
+            if self.websocket_server:
+                self.websocket_server.claude_status_changed(
+                    status="running",
+                    pid=process.pid,
+                    message="Claude subprocess started"
+                )
+            
+            # Set terminal to raw mode for proper interaction
+            if sys.stdin.isatty():
+                tty.setraw(sys.stdin)
+            
+            # Handle Ctrl+C gracefully
+            def signal_handler(signum, frame):
+                if process.poll() is None:
+                    process.terminate()
+                raise KeyboardInterrupt()
+            
+            signal.signal(signal.SIGINT, signal_handler)
+            
+            # I/O loop
+            while True:
+                # Check if process is still running
+                if process.poll() is not None:
+                    break
+                
+                # Check for data from Claude or stdin
+                r, _, _ = select.select([master_fd, sys.stdin], [], [], 0)
+                
+                if master_fd in r:
+                    try:
+                        data = os.read(master_fd, 4096)
+                        if data:
+                            os.write(sys.stdout.fileno(), data)
+                            # Broadcast output to WebSocket clients
+                            if self.websocket_server:
+                                try:
+                                    # Decode and send
+                                    output = data.decode('utf-8', errors='replace')
+                                    self.websocket_server.claude_output(output, "stdout")
+                                except Exception as e:
+                                    self.logger.debug(f"Failed to broadcast output: {e}")
+                        else:
+                            break  # EOF
+                    except OSError:
+                        break
+                
+                if sys.stdin in r:
+                    try:
+                        data = os.read(sys.stdin.fileno(), 4096)
+                        if data:
+                            os.write(master_fd, data)
+                    except OSError:
+                        break
+            
+            # Wait for process to complete
+            process.wait()
+            
+            if self.project_logger:
+                self.project_logger.log_system(
+                    f"Claude subprocess exited with code {process.returncode}",
+                    level="INFO",
+                    component="subprocess"
+                )
+            
+            # Notify WebSocket clients
+            if self.websocket_server:
+                self.websocket_server.claude_status_changed(
+                    status="stopped",
+                    message=f"Claude subprocess exited with code {process.returncode}"
+                )
+            
+        finally:
+            # Restore terminal
+            if original_tty and sys.stdin.isatty():
+                termios.tcsetattr(sys.stdin, termios.TCSADRAIN, original_tty)
+            
+            # Close PTY
+            try:
+                os.close(master_fd)
+            except:
+                pass
+            
+            # Ensure process is terminated
+            if 'process' in locals() and process.poll() is None:
+                process.terminate()
+                try:
+                    process.wait(timeout=2)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait()
+            
+            # End WebSocket session if in subprocess mode
+            if self.websocket_server:
+                self.websocket_server.session_ended()
 
 
 def create_simple_context() -> str:
@@ -622,10 +898,14 @@ automatically normalize them to lowercase-hyphenated format for the Task tool.
 Work efficiently and delegate appropriately to subagents when needed."""
 
 
+# Backward compatibility alias
+SimpleClaudeRunner = ClaudeRunner
+
+
 # Convenience functions for backward compatibility
 def run_claude_interactive(context: Optional[str] = None):
     """Run Claude interactively with optional context."""
-    runner = SimpleClaudeRunner()
+    runner = ClaudeRunner()
     if context is None:
         context = create_simple_context()
     runner.run_interactive(context)
@@ -633,7 +913,7 @@ def run_claude_interactive(context: Optional[str] = None):
 
 def run_claude_oneshot(prompt: str, context: Optional[str] = None) -> bool:
     """Run Claude with a single prompt."""
-    runner = SimpleClaudeRunner()
+    runner = ClaudeRunner()
     if context is None:
         context = create_simple_context()
     return runner.run_oneshot(prompt, context)