claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/services/cli/session_manager.py

@@ -11,14 +11,16 @@ DESIGN DECISIONS:
 - Automatic session cleanup and archiving
 - Thread-safe session operations
 - Non-blocking validation with structured warnings
+- Async-first design with periodic auto-save task
 """
 
+import asyncio
 import gzip
 import json
 import uuid
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -151,8 +153,12 @@ class SessionInfo:
 
     id: str
     context: str = "default"
-    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
-    last_used: str = field(default_factory=lambda: datetime.now().isoformat())
+    created_at: str = field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+    last_used: str = field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
     use_count: int = 0
     agents_run: List[Dict[str, Any]] = field(default_factory=list)
     metadata: Dict[str, Any] = field(default_factory=dict)
@@ -175,8 +181,8 @@ class SessionInfo:
         return cls(
             id=data["id"],
             context=data.get("context", "default"),
-            created_at=data.get("created_at", datetime.now().isoformat()),
-            last_used=data.get("last_used", datetime.now().isoformat()),
+            created_at=data.get("created_at", datetime.now(timezone.utc).isoformat()),
+            last_used=data.get("last_used", datetime.now(timezone.utc).isoformat()),
             use_count=data.get("use_count", 0),
             agents_run=data.get("agents_run", []),
             metadata=data.get("metadata", {}),
@@ -213,8 +219,39 @@ class SessionManager(ISessionManager):
         self.config_service = config_service
         self.logger = get_logger("SessionManager")
         self._sessions_cache: Dict[str, SessionInfo] = {}
+        self._auto_save_task: Optional[asyncio.Task] = None
+        self._running = False
         self._load_sessions()
 
+        # Start auto-save task if enabled and event loop is running
+        if config_service:
+            auto_save_enabled = config_service.get("session.auto_save", True)
+            if auto_save_enabled:
+                self._start_auto_save()
+            else:
+                self.logger.info("Auto-save disabled by configuration")
+        else:
+            self.logger.debug("No config service provided, auto-save not started")
+
+    def _start_auto_save(self) -> None:
+        """Start the auto-save background task.
+
+        WHY: Separated from __init__ to allow safe initialization without event loop.
+        Can be called when event loop is available.
+        """
+        try:
+            loop = asyncio.get_running_loop()
+            self._running = True
+            self._auto_save_task = loop.create_task(self._periodic_session_save())
+            self.logger.info("Auto-save task started")
+        except RuntimeError:
+            # No event loop running, schedule for later
+            self.logger.debug(
+                "No event loop running, auto-save will start when loop is available"
+            )
+            # Set flag so we know to start it later
+            self._running = True
+
     def create_session(
         self, context: str = "default", options: Optional[Dict[str, Any]] = None
     ) -> SessionInfo:
@@ -284,7 +321,7 @@ class SessionManager(ISessionManager):
         # Check session age
         try:
             created = datetime.fromisoformat(session.created_at)
-            age = datetime.now() - created
+            age = datetime.now(timezone.utc) - created
 
             if age > timedelta(days=7):
                 validation.warnings.append(f"Session is {age.days} days old")
@@ -355,10 +392,10 @@ class SessionManager(ISessionManager):
             {
                 "agent": agent,
                 "task": task[:100],  # Truncate long tasks
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             }
         )
-        session.last_used = datetime.now().isoformat()
+        session.last_used = datetime.now(timezone.utc).isoformat()
         session.use_count += 1
 
         self.save_session(session)
@@ -370,7 +407,7 @@ class SessionManager(ISessionManager):
 
         WHY: Prevents unbounded growth of session data and improves performance.
         """
-        now = datetime.now()
+        now = datetime.now(timezone.utc)
         max_age = timedelta(hours=max_age_hours)
 
         expired_ids = []
@@ -418,7 +455,7 @@ class SessionManager(ISessionManager):
             return True
 
         # Create timestamped archive file
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
         archive_name = f"sessions_archive_{timestamp}.json.gz"
         archive_path = archive_dir / archive_name
 
@@ -445,7 +482,7 @@ class SessionManager(ISessionManager):
             sessions_dict = {
                 sid: session.to_dict() for sid, session in self._sessions_cache.items()
             }
-            with open(session_file, "w") as f:
+            with session_file.open("w") as f:
                 json.dump(sessions_dict, f, indent=2)
         except Exception as e:
             self.logger.error(f"Failed to save sessions: {e}")
@@ -460,7 +497,7 @@ class SessionManager(ISessionManager):
             return
 
         try:
-            with open(session_file) as f:
+            with session_file.open() as f:
                 sessions_dict = json.load(f)
 
             self._sessions_cache = {
@@ -473,6 +510,60 @@ class SessionManager(ISessionManager):
             self.logger.error(f"Failed to load sessions: {e}")
             self._sessions_cache = {}
 
+    async def _periodic_session_save(self) -> None:
+        """Periodically save sessions to disk.
+
+        WHY: Ensures sessions are persisted regularly to prevent data loss.
+        Follows the async pattern from EventAggregator._periodic_cleanup().
+        """
+        if not self.config_service:
+            self.logger.warning("No config service, cannot determine save interval")
+            return
+
+        save_interval = self.config_service.get("session.save_interval", 300)
+        self.logger.info(f"Starting periodic session save (interval: {save_interval}s)")
+
+        while self._running:
+            try:
+                await asyncio.sleep(save_interval)
+
+                if self._sessions_cache:
+                    self._save_sessions()
+                    self.logger.debug(
+                        f"Auto-saved {len(self._sessions_cache)} session(s)"
+                    )
+                else:
+                    self.logger.debug("No sessions to save")
+
+            except asyncio.CancelledError:
+                self.logger.info("Auto-save task cancelled")
+                break
+            except Exception as e:
+                self.logger.error(f"Error in auto-save task: {e}")
+
+    async def cleanup(self) -> None:
+        """Clean up resources and stop background tasks.
+
+        WHY: Ensures graceful shutdown of the SessionManager and all background tasks.
+        """
+        self.logger.info("Shutting down SessionManager...")
+        self._running = False
+
+        # Cancel auto-save task
+        if self._auto_save_task and not self._auto_save_task.done():
+            self._auto_save_task.cancel()
+            try:
+                await self._auto_save_task
+            except asyncio.CancelledError:
+                pass
+
+        # Final save before shutdown
+        if self._sessions_cache:
+            self._save_sessions()
+            self.logger.info(f"Final save: {len(self._sessions_cache)} session(s)")
+
+        self.logger.info("SessionManager shutdown complete")
+
 
 # Context manager for session management
 class ManagedSession:
@@ -509,5 +600,5 @@ class ManagedSession:
         """Exit session context with cleanup."""
         if self.session:
             # Update last used time
-            self.session.last_used = datetime.now().isoformat()
+            self.session.last_used = datetime.now(timezone.utc).isoformat()
             self.manager.save_session(self.session)