claude-mpm 3.9.11__py3-none-any.whl → 4.0.4__py3-none-any.whl

claude_mpm/services/session_management_service.py

@@ -0,0 +1,304 @@
+from pathlib import Path
+
+"""Session management service for orchestrating Claude sessions.
+
+This service handles:
+1. Interactive session orchestration
+2. Oneshot session orchestration
+3. Session lifecycle management
+4. Session logging and cleanup
+
+Extracted from ClaudeRunner to follow Single Responsibility Principle.
+"""
+
+import time
+import uuid
+from typing import Any, Dict, List, Optional
+
+from claude_mpm.core.base_service import BaseService
+from claude_mpm.services.core.interfaces import SessionManagementInterface
+
+
+class SessionManagementService(BaseService, SessionManagementInterface):
+    """Service for managing Claude session orchestration."""
+
+    def __init__(self, runner=None):
+        """Initialize the session management service.
+
+        Args:
+            runner: ClaudeRunner instance for delegation
+        """
+        super().__init__(name="session_management_service")
+        self.runner = runner
+        self.active_sessions = {}  # Track active sessions
+
+    async def _initialize(self) -> None:
+        """Initialize the service. No special initialization needed."""
+        pass
+
+    async def _cleanup(self) -> None:
+        """Cleanup service resources. No cleanup needed."""
+        pass
+
+    def run_interactive_session(self, initial_context: Optional[str] = None) -> bool:
+        """Run Claude in interactive mode using session delegation.
+
+        WHY: This method delegates to InteractiveSession class for better
+        maintainability and reduced complexity. The session class handles all
+        the details while this method provides the orchestration interface.
+
+        Args:
+            initial_context: Optional initial context to pass to Claude
+
+        Returns:
+            bool: True if session completed successfully, False otherwise
+        """
+        try:
+            from claude_mpm.core.interactive_session import InteractiveSession
+
+            # Create session handler
+            session = InteractiveSession(self.runner)
+
+            # Step 1: Initialize session
+            success, error = session.initialize_interactive_session()
+            if not success:
+                self.logger.error(f"Failed to initialize interactive session: {error}")
+                return False
+
+            # Step 2: Set up environment
+            success, environment = session.setup_interactive_environment()
+            if not success:
+                self.logger.error("Failed to setup interactive environment")
+                return False
+
+            # Step 3: Handle interactive input/output
+            # This is where the actual Claude process runs
+            session.handle_interactive_input(environment)
+
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Interactive session failed: {e}")
+            return False
+        finally:
+            # Step 4: Clean up session
+            if "session" in locals():
+                session.cleanup_interactive_session()
+
+    def run_oneshot_session(self, prompt: str, context: Optional[str] = None) -> bool:
+        """Run Claude with a single prompt using session delegation.
+
+        WHY: This method delegates to OneshotSession class for better
+        maintainability and reduced complexity. The session class handles
+        all the details while this method provides the orchestration interface.
+
+        Args:
+            prompt: The command or prompt to execute
+            context: Optional context to prepend to the prompt
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        try:
+            from claude_mpm.core.oneshot_session import OneshotSession
+
+            # Create session handler
+            session = OneshotSession(self.runner)
+
+            # Step 1: Initialize session
+            success, error = session.initialize_session(prompt)
+            if not success:
+                return False
+
+            # Special case: MPM commands return early
+            if (
+                error is None
+                and self.runner.command_handler_service
+                and self.runner.command_handler_service.is_mpm_command(prompt)
+            ):
+                return success
+
+            # Step 2: Deploy agents
+            if not session.deploy_agents():
+                self.logger.warning("Agent deployment had issues, continuing...")
+
+            # Step 3: Set up infrastructure
+            infrastructure = session.setup_infrastructure()
+
+            # Step 4: Execute command
+            success, response = session.execute_command(prompt, context, infrastructure)
+
+            return success
+
+        except Exception as e:
+            self.logger.error(f"Oneshot session failed: {e}")
+            return False
+        finally:
+            # Step 5: Clean up session
+            if "session" in locals():
+                session.cleanup_session()
+
+    def create_session_log_file(self) -> Optional[Path]:
+        """Create a session log file for the current session.
+
+        Returns:
+            Path to the created log file, or None if creation failed
+        """
+        try:
+            import uuid
+            from datetime import datetime
+
+            from claude_mpm.config.paths import paths
+
+            # Create session logs directory if it doesn't exist
+            session_logs_dir = paths.project_root / ".claude-mpm" / "logs" / "sessions"
+            session_logs_dir.mkdir(parents=True, exist_ok=True)
+
+            # Generate unique session log filename
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            session_id = str(uuid.uuid4())[:8]
+            log_filename = f"session_{timestamp}_{session_id}.jsonl"
+            log_file = session_logs_dir / log_filename
+
+            # Create empty log file
+            log_file.touch()
+
+            self.logger.debug(f"Created session log file: {log_file}")
+            return log_file
+
+        except Exception as e:
+            self.logger.warning(f"Failed to create session log file: {e}")
+            return None
+
+    def log_session_event(self, log_file: Path, event_data: dict):
+        """Log an event to the session log file.
+
+        Args:
+            log_file: Path to the session log file
+            event_data: Event data to log
+        """
+        if not log_file or not log_file.exists():
+            return
+
+        try:
+            import json
+            from datetime import datetime
+
+            # Add timestamp to event data
+            event_data["timestamp"] = datetime.now().isoformat()
+
+            # Append to log file as JSONL
+            with open(log_file, "a") as f:
+                f.write(json.dumps(event_data) + "\n")
+
+        except Exception as e:
+            self.logger.warning(f"Failed to log session event: {e}")
+
+    def get_service_status(self) -> dict:
+        """Get current session management service status.
+
+        Returns:
+            dict: Session management service status information
+        """
+        return {
+            "service_available": True,
+            "runner_available": self.runner is not None,
+            "interactive_session_available": True,
+            "oneshot_session_available": True,
+            "active_sessions": len(self.active_sessions),
+        }
+
+    # Implementation of abstract methods from SessionManagementInterface
+
+    def start_session(self, session_config: Dict[str, Any]) -> str:
+        """Start a new session.
+
+        Args:
+            session_config: Configuration for the session
+
+        Returns:
+            Session ID
+        """
+        session_id = str(uuid.uuid4())
+        session_info = {
+            "id": session_id,
+            "config": session_config,
+            "start_time": time.time(),
+            "status": "active",
+            "type": session_config.get("type", "interactive"),
+        }
+
+        self.active_sessions[session_id] = session_info
+        self.logger.info(f"Started session {session_id}")
+
+        return session_id
+
+    def end_session(self, session_id: str) -> bool:
+        """End an active session.
+
+        Args:
+            session_id: ID of session to end
+
+        Returns:
+            True if session ended successfully
+        """
+        if session_id in self.active_sessions:
+            session_info = self.active_sessions[session_id]
+            session_info["status"] = "ended"
+            session_info["end_time"] = time.time()
+
+            # Remove from active sessions
+            del self.active_sessions[session_id]
+
+            self.logger.info(f"Ended session {session_id}")
+            return True
+        else:
+            self.logger.warning(f"Session {session_id} not found")
+            return False
+
+    def get_session_status(self, session_id: str) -> Dict[str, Any]:
+        """Get status of a session.
+
+        Args:
+            session_id: ID of session
+
+        Returns:
+            Dictionary with session status information
+        """
+        if session_id in self.active_sessions:
+            return self.active_sessions[session_id].copy()
+        else:
+            return {
+                "id": session_id,
+                "status": "not_found",
+                "error": "Session not found",
+            }
+
+    def list_active_sessions(self) -> List[str]:
+        """List all active session IDs.
+
+        Returns:
+            List of active session IDs
+        """
+        return list(self.active_sessions.keys())
+
+    async def cleanup_sessions(self) -> int:
+        """Clean up inactive or expired sessions.
+
+        Returns:
+            Number of sessions cleaned up
+        """
+        current_time = time.time()
+        expired_sessions = []
+
+        # Find sessions older than 24 hours
+        for session_id, session_info in self.active_sessions.items():
+            if current_time - session_info["start_time"] > 86400:  # 24 hours
+                expired_sessions.append(session_id)
+
+        # Clean up expired sessions
+        for session_id in expired_sessions:
+            self.end_session(session_id)
+
+        self.logger.info(f"Cleaned up {len(expired_sessions)} expired sessions")
+        return len(expired_sessions)

claude_mpm/services/socketio/__init__.py

@@ -7,11 +7,11 @@ with separated event handlers for improved maintainability.
 from .handlers import (
     BaseEventHandler,
     ConnectionEventHandler,
-    ProjectEventHandler,
-    MemoryEventHandler,
+    EventHandlerRegistry,
     FileEventHandler,
     GitEventHandler,
-    EventHandlerRegistry,
+    MemoryEventHandler,
+    ProjectEventHandler,
 )
 
 __all__ = [
@@ -22,4 +22,4 @@ __all__ = [
     "FileEventHandler",
     "GitEventHandler",
     "EventHandlerRegistry",
-]
+]

claude_mpm/services/socketio/client_proxy.py

@@ -0,0 +1,174 @@
+"""
+SocketIO Client Proxy for claude-mpm.
+
+WHY: This module contains the SocketIOClientProxy class that was extracted from
+the monolithic socketio_server.py file. In exec mode, a persistent Socket.IO
+server runs in a separate process, and this proxy provides a Socket.IO-like
+interface without starting another server.
+
+DESIGN DECISION: Separated client proxy logic from server logic for better
+organization and to reduce the complexity of the main server file.
+"""
+
+import asyncio
+import threading
+import time
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Set
+
+try:
+    import socketio
+
+    SOCKETIO_AVAILABLE = True
+except ImportError:
+    SOCKETIO_AVAILABLE = False
+    socketio = None
+
+from ...core.logging_config import get_logger
+
+
+class SocketIOClientProxy:
+    """Proxy that connects to an existing Socket.IO server as a client.
+
+    WHY: In exec mode, a persistent Socket.IO server runs in a separate process.
+    The hook handler in the Claude process needs a Socket.IO-like interface
+    but shouldn't start another server. This proxy provides that interface
+    while the actual events are handled by the persistent server.
+    """
+
+    def __init__(self, host: str = "localhost", port: int = 8765):
+        self.host = host
+        self.port = port
+        self.logger = get_logger(__name__ + ".SocketIOClientProxy")
+        self.running = True  # Always "running" for compatibility
+        self._sio_client = None
+        self._client_thread = None
+        self._client_loop = None
+
+    def start_sync(self):
+        """Start the Socket.IO client connection to the persistent server."""
+        self.logger.debug(
+            f"SocketIOClientProxy: Connecting to server on {self.host}:{self.port}"
+        )
+        if SOCKETIO_AVAILABLE:
+            self._start_client()
+
+    def stop_sync(self):
+        """Stop the Socket.IO client connection."""
+        self.logger.debug(f"SocketIOClientProxy: Disconnecting from server")
+        if self._sio_client:
+            self._sio_client.disconnect()
+
+    def _start_client(self):
+        """Start Socket.IO client in a background thread."""
+
+        def run_client():
+            self._client_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._client_loop)
+            try:
+                self._client_loop.run_until_complete(self._connect_and_run())
+            except Exception as e:
+                self.logger.error(f"SocketIOClientProxy client thread error: {e}")
+            finally:
+                self._client_loop.close()
+
+        self._client_thread = threading.Thread(target=run_client, daemon=True)
+        self._client_thread.start()
+        # Give it a moment to connect
+        time.sleep(0.2)
+
+    async def _connect_and_run(self):
+        """Connect to the persistent Socket.IO server and keep connection alive."""
+        try:
+            self._sio_client = socketio.AsyncClient()
+
+            @self._sio_client.event
+            async def connect():
+                self.logger.info(
+                    f"SocketIOClientProxy: Connected to server at http://{self.host}:{self.port}"
+                )
+
+            @self._sio_client.event
+            async def disconnect():
+                self.logger.info(f"SocketIOClientProxy: Disconnected from server")
+
+            # Connect to the server
+            await self._sio_client.connect(f"http://127.0.0.1:{self.port}")
+
+            # Keep the connection alive until stopped
+            while self.running:
+                await asyncio.sleep(1)
+
+        except Exception as e:
+            self.logger.error(f"SocketIOClientProxy: Connection error: {e}")
+            self._sio_client = None
+
+    def broadcast_event(self, event_type: str, data: Dict[str, Any]):
+        """Send event to the persistent Socket.IO server."""
+        if not SOCKETIO_AVAILABLE:
+            return
+
+        # Ensure client is started
+        if not self._client_thread or not self._client_thread.is_alive():
+            self.logger.debug(f"SocketIOClientProxy: Starting client for {event_type}")
+            self._start_client()
+
+        if self._sio_client and self._sio_client.connected:
+            try:
+                event = {
+                    "type": event_type,
+                    "timestamp": datetime.now().isoformat(),
+                    "data": data,
+                }
+
+                # Send event safely using run_coroutine_threadsafe
+                if (
+                    hasattr(self, "_client_loop")
+                    and self._client_loop
+                    and not self._client_loop.is_closed()
+                ):
+                    try:
+                        future = asyncio.run_coroutine_threadsafe(
+                            self._sio_client.emit("claude_event", event),
+                            self._client_loop,
+                        )
+                        # Don't wait for the result to avoid blocking
+                        self.logger.debug(
+                            f"SocketIOClientProxy: Scheduled emit for {event_type}"
+                        )
+                    except Exception as e:
+                        self.logger.error(
+                            f"SocketIOClientProxy: Failed to schedule emit for {event_type}: {e}"
+                        )
+                else:
+                    self.logger.warning(
+                        f"SocketIOClientProxy: Client event loop not available for {event_type}"
+                    )
+
+                self.logger.debug(f"SocketIOClientProxy: Sent event {event_type}")
+            except Exception as e:
+                self.logger.error(
+                    f"SocketIOClientProxy: Failed to send event {event_type}: {e}"
+                )
+        else:
+            self.logger.warning(
+                f"SocketIOClientProxy: Client not ready for {event_type}"
+            )
+
+    # Compatibility methods for WebSocketServer interface
+    def session_started(self, session_id: str, launch_method: str, working_dir: str):
+        self.logger.debug(f"SocketIOClientProxy: Session started {session_id}")
+
+    def session_ended(self):
+        self.logger.debug(f"SocketIOClientProxy: Session ended")
+
+    def claude_status_changed(
+        self, status: str, pid: Optional[int] = None, message: str = ""
+    ):
+        self.logger.debug(f"SocketIOClientProxy: Claude status {status}")
+
+    def agent_delegated(self, agent: str, task: str, status: str = "started"):
+        self.logger.debug(f"SocketIOClientProxy: Agent {agent} delegated")
+
+    def todo_updated(self, todos: List[Dict[str, Any]]):
+        self.logger.debug(f"SocketIOClientProxy: Todo updated ({len(todos)} todos)")

claude_mpm/services/socketio/handlers/__init__.py

@@ -8,10 +8,10 @@ and maintainability.
 
 from .base import BaseEventHandler
 from .connection import ConnectionEventHandler
-from .project import ProjectEventHandler
-from .memory import MemoryEventHandler
 from .file import FileEventHandler
 from .git import GitEventHandler
+from .memory import MemoryEventHandler
+from .project import ProjectEventHandler
 from .registry import EventHandlerRegistry
 
 __all__ = [
@@ -22,4 +22,4 @@ __all__ = [
     "FileEventHandler",
     "GitEventHandler",
     "EventHandlerRegistry",
-]
+]

claude_mpm/services/socketio/handlers/base.py

@@ -6,52 +6,55 @@ classes inherit from this to ensure consistent behavior.
 """
 
 import logging
-from typing import Any, Dict, Optional, List, TYPE_CHECKING
 from datetime import datetime
 from logging import Logger
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from ....core.logger import get_logger
-from ....core.typing_utils import EventName, EventData, SocketId
+from ....core.typing_utils import EventData, EventName, SocketId
 
 if TYPE_CHECKING:
-    from ..server import SocketIOServer
     import socketio
 
+    from ..server import SocketIOServer
+
 
 class BaseEventHandler:
     """Base class for Socket.IO event handlers.
-    
+
     WHY: Provides common functionality and structure for all event handlers,
     ensuring consistent error handling, logging, and server access patterns.
     Each handler focuses on a specific domain while sharing common infrastructure.
     """
-    
-    def __init__(self, server: 'SocketIOServer') -> None:
+
+    def __init__(self, server: "SocketIOServer") -> None:
         """Initialize the base handler.
-        
+
         Args:
             server: The SocketIOServer instance that owns this handler
         """
-        self.server: 'SocketIOServer' = server
-        self.sio: 'socketio.AsyncServer' = server.sio
+        self.server: "SocketIOServer" = server
+        self.sio: "socketio.AsyncServer" = server.sio
         self.logger: Logger = get_logger(self.__class__.__name__)
         self.clients: Dict[SocketId, Dict[str, Any]] = server.clients
         self.event_history: List[Dict[str, Any]] = server.event_history
-    
+
     def register_events(self) -> None:
         """Register all events handled by this handler.
-        
+
         WHY: This method must be implemented by each handler subclass
         to register its specific events with the Socket.IO server.
         """
         raise NotImplementedError("Subclasses must implement register_events()")
-    
-    async def emit_to_client(self, sid: SocketId, event: EventName, data: EventData) -> None:
+
+    async def emit_to_client(
+        self, sid: SocketId, event: EventName, data: EventData
+    ) -> None:
         """Emit an event to a specific client.
-        
+
         WHY: Centralizes client communication with consistent error handling
         and logging for debugging connection issues.
-        
+
         Args:
             sid: Socket.IO session ID of the client
             event: Event name to emit
@@ -63,34 +66,40 @@ class BaseEventHandler:
         except Exception as e:
             self.logger.error(f"Failed to emit {event} to client {sid}: {e}")
             import traceback
+
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
-    
-    async def broadcast_event(self, event: EventName, data: EventData, skip_sid: Optional[SocketId] = None) -> None:
+
+    async def broadcast_event(
+        self, event: EventName, data: EventData, skip_sid: Optional[SocketId] = None
+    ) -> None:
         """Broadcast an event to all connected clients.
-        
+
         WHY: Provides consistent broadcasting with optional exclusion
         of the originating client.
-        
+
         Args:
             event: Event name to broadcast
             data: Data to send with the event
             skip_sid: Optional session ID to skip
         """
         try:
+            self.logger.info(f"🔔 Broadcasting {event} (skip_sid={skip_sid})")
             if skip_sid:
                 await self.sio.emit(event, data, skip_sid=skip_sid)
             else:
                 await self.sio.emit(event, data)
-            self.logger.debug(f"Broadcasted {event} to all clients")
+            self.logger.info(f"✅ Broadcasted {event} to all clients")
         except Exception as e:
             self.logger.error(f"Failed to broadcast {event}: {e}")
-    
+            import traceback
+            self.logger.error(f"Stack trace: {traceback.format_exc()}")
+
     def add_to_history(self, event_type: str, data: EventData) -> None:
         """Add an event to the server's event history.
-        
+
         WHY: Maintains a history of events for new clients to receive
         when they connect, ensuring they have context.
-        
+
         Args:
             event_type: Type of the event
             data: Event data
@@ -98,17 +107,21 @@ class BaseEventHandler:
         event = {
             "type": event_type,
             "timestamp": datetime.utcnow().isoformat() + "Z",
-            "data": data
+            "data": data,
         }
         self.event_history.append(event)
-        self.logger.debug(f"Added {event_type} to history (total: {len(self.event_history)})")
-    
-    def log_error(self, operation: str, error: Exception, context: Optional[Dict[str, Any]] = None) -> None:
+        self.logger.debug(
+            f"Added {event_type} to history (total: {len(self.event_history)})"
+        )
+
+    def log_error(
+        self, operation: str, error: Exception, context: Optional[Dict[str, Any]] = None
+    ) -> None:
         """Log an error with context.
-        
+
         WHY: Provides consistent error logging with context information
         for debugging issues in production.
-        
+
         Args:
             operation: Description of the operation that failed
             error: The exception that occurred
@@ -118,4 +131,5 @@ class BaseEventHandler:
         if context:
             self.logger.error(f"Context: {context}")
         import traceback
-        self.logger.error(f"Stack trace: {traceback.format_exc()}")
+
+        self.logger.error(f"Stack trace: {traceback.format_exc()}")